Fast and dirty

public IActionResult Test([FromBody]TestModel model)

public class TestModel
{
  [Required]
  public string A { get; set; }
  [BindRequired]
  public string B { get; set; }
}

{ A:'Something',B:'Something else' }

var valid = TryUpdateModelAsync(model).Result;

More work

public IActionResult Test(TestModel model)

What does it mean?

• Trying out .NET Core and VS Code - Console Hello World
• ASP.Net Core with Visual Studio Code
• ASP.Net Core Web API with Visual Studio Code

Setup

Creating the ASP.Net project

1. Create a new folder
2. Open a command prompt in it (Update: Core has a Terminal window in it now, which one can use)
3. Type dotnet new -t Web
4. Open Visual Studio Code and select the newly created folder
5. To the prompt "Required assets to build and debug are missing from your project. Add them?" choose Yes

• Sample pages using ASP.NET Core MVC
• Gulp and Bower for managing client-side libraries
• Theming using Bootstrap

"launchBrowser" : {
"enabled" : true,
"args" : "${auto-detect-url}",
"windows" : {
"command" : "cmd.exe",
"args" : "/C start ${auto-detect-url}"
},
"osx" : {
"command" : "open"
},
"linux" : {
"command" : "xdg-open"
}
}

{
"name": "webapplication",
"private": true,
"dependencies": {
"bootstrap": "3.3.6",
"jquery": "2.2.3",
"jquery-validation": "1.15.0",
"jquery-validation-unobtrusive": "3.2.6"
}
}

{
"directory": "wwwroot/lib"
}

Installing tools for client side package management

Git

Node.js

Bower

npm install -g bower

Gulp

npm install --global gulp

npm install --save-dev gulp

{
"name": "webapplication",
"version": "0.0.0",
"private": true,
"devDependencies": {
"gulp": "3.9.1",
"gulp-concat": "2.6.0",
"gulp-cssmin": "0.1.7",
"gulp-uglify": "1.5.3",
"rimraf": "2.5.2"
}
}

npm install --save-dev

npm install --save-dev >nul

"scripts": {
"prepublish": [ "npm install", "bower install", "gulp clean", "gulp min" ],
"postpublish": [ "dotnet publish-iis --publish-folder %publish:OutputPath% --framework %publish:FullTargetFramework%" ]
}

Exploring the project

project.json will be phased out

node_modules

Program and Startup

public IConfigurationRoot Configuration { get; }

var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);

Configuration = builder.Build();

{
"ConnectionStrings": {
"DefaultConnection": "Data Source=WebApplication.db"
},
"Logging": {
"IncludeScopes": false,
"LogLevel": {
"Default": "Debug",
"System": "Information",
"Microsoft": "Information"
}
}
}

services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlite(Configuration.GetConnectionString("DefaultConnection"))
);

loggerFactory.AddConsole(Configuration.GetSection("Logging"));

• App Secrets - built into the configuration instance with

  builder.AddUserSecrets();

• Using environment variables to overwrite the ones in the json files - built into the configuration with

  builder.AddEnvironmentVariables();

• MVC Routing - used in the app with

  app.UseMvc(routes =>
  {
  routes.MapRoute(
  name: "default",
  template: "{controller=Home}/{action=Index}/{id?}");
  });

Database

services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlite(Configuration.GetConnectionString("DefaultConnection"))
);

"Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore": "1.0.0",
"Microsoft.AspNetCore.Identity.EntityFrameworkCore": "1.0.0",
"Microsoft.EntityFrameworkCore.Sqlite": "1.0.0",
"Microsoft.EntityFrameworkCore.Tools": {
"version": "1.0.0-preview2-final",
"type": "build"
}

dotnet ef database update

if (env.IsDevelopment())
{
...
app.UseDatabaseErrorPage();
...
}

Installing SQLite

Controllers

• HomeController - the simplest possible controller, it displays the home view
• AccountController and ManageController - responsible for account management, they have a lot of functionality including antiforgery token, forgot the password, external login providers, two factor authentication, email and SMS sending, reset password, change email, etc. Of course, register, login and logoff.
• IEmailSender, ISMSSender and MessageServices - if we waited until this moment for me to reveal the simple and free email/SMS provider architecture in the project, you will be disappointed. MessageServices implements both IEmailSender and ISMSSender with empty methods where you should plus useful code.
• Views - all views are interesting to explore. They show basic and sometimes not so basics concepts of Razor Model/View/Controller interaction like: imports, declaring the controller and action names in the form element instead of a string URL, declaring the @model type for a view, validation summaries, inline code, partial views, model to view synchronization, variable view content depending on environment (production, staging), fallback source and automated testing that the script loaded, bootstrap theming, etc.
• Models - model classes are simple POCOs, but they do provide their occasional instruction, like using annotations for data structure, validation and display purposes alike

Running the website

dotnet run

dotnet compiled.dll

Conclusions

• Trying out .NET Core and VS Code - Console Hello World
• ASP.Net Core with Visual Studio Code
• ASP.Net Core Web API with Visual Studio Code
• The default Core website with Visual Studio Code

Setup

1. Create a folder for our project called WebCore
2. In it create an API folder
3. Open a command prompt in the API folder and type 'dotnet new web' (in .NET Core 1.0 you could omit the template, but from 1.1 you need to use it explicitly)
4. Open Visual Studio Code by typing 'code' or by any other means
5. Close the command prompt window
6. In Code select the API folder and open Program.cs
7. To the warning "Required assets to build and debug are missing from your project. Add them?" click Yes
8. To the info "There are unresolved dependencies from '<your project>.csproj'. Please execute the restore command to continue." click Restore
9. Change the namespace to WebCore.API
10. Press Ctrl-Shift-B to build the project.

,"Microsoft.AspNetCore.Mvc": "1.0.0"
,"Microsoft.AspNetCore.Mvc.Core": "1.0.0"

<PackageReference Include="Microsoft.AspNetCore.Mvc" Version="1.1.1" />

{
  "version": "1.0.0-*",
  "buildOptions": {
    "debugType": "portable",
    "emitEntryPoint": true
  },
  "dependencies": {},
  "frameworks": {
    "netcoreapp1.0": {
      "dependencies": {
        "Microsoft.NETCore.App": {
          "type": "platform",
          "version": "1.0.0"
        },
        "Microsoft.AspNetCore.Server.Kestrel": "1.0.0",
        "Microsoft.AspNetCore.Mvc": "1.0.0",
        "Microsoft.AspNetCore.Mvc.Core": "1.0.0"
      },
      "imports": "dnxcore50"
    }
  }
}

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>netcoreapp1.1</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <Folder Include="wwwroot\" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore" Version="1.1.1" />
    <PackageReference Include="Microsoft.AspNetCore.Mvc" Version="1.1.1" />
  </ItemGroup>

</Project>

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting;

namespace WebCore.API
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var host = new WebHostBuilder()
                .UseKestrel()
                .UseContentRoot(Directory.GetCurrentDirectory())
                .UseIISIntegration()
                .UseStartup<Startup>()
                .Build();

            host.Run();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace WebCore.API
{
    public class Startup
    {
        // This method gets called by the runtime. Use this method to add services to the container.
        // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
        {
            loggerFactory.AddConsole();

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseMvcWithDefaultRoute();

            /*app.Run(async (context) =>
            {
                await context.Response.WriteAsync("Hello World!");
            });*/
        }
    }
}

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": ".NET Core Launch (web API)",
            "type": "coreclr",
            "request": "launch",
            "preLaunchTask": "build",
            "program": "${workspaceRoot}/bin/Debug/netcoreapp1.0/API.dll",
            "args": [],
            "cwd": "${workspaceRoot}",
            "externalConsole": false,
            "stopAtEntry": false
        }
    ]
}

The Controller

using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;

namespace WebCore.API.Controllers
{
    [Route("api/[controller]")]
    public class NoteController : Controller
    {
        private static List<Note> _notes;
        static NoteController()
        {
            _notes = new List<Note>();
        }


        [HttpGet]
        public IEnumerable<Note> GetAll()
        {
            return _notes.AsReadOnly();
        }

        [HttpGet("{id}", Name = "GetNote")]
        public IActionResult GetById(string id)
        {
            var item = _notes.Find(n => n.Id == id);
            if (item == null)
            {
                return NotFound();
            }
            return new ObjectResult(item);
        }

        [HttpPost]
        public IActionResult Create([FromBody] Note item)
        {
            if (item == null)
            {
                return BadRequest();
            }
            item.Id = (_notes.Count + 1).ToString();
            _notes.Add(item);
            return CreatedAtRoute("GetNote", new { controller = "Note", id = item.Id }, item);
        }

        [HttpDelete("{id}")]
        public void Delete(string id)
        {
            _notes.RemoveAll(n => n.Id == id);
        }

        public class Note
        {
            public string Id { get; set; }
            public string Content { get; set; }
        }
    }
}

Testing the result

{
    Content:'test'
}

{
  "id": "1",
  "content": "test"
}

More complexity

app.UseMvcWithDefaultRoute();

services.AddSingleton();

Security

Impressions on Visual Studio Code

• Trying out .NET Core and VS Code - Console Hello World
• ASP.Net Core with Visual Studio Code
• ASP.Net Core Web API with Visual Studio Code
• The default Core website with Visual Studio Code

Reading into it

Hello World - web style

1. Go to the Explorer icon and click on Open Folder (or File → Open Folder)
2. Create a Code Hello World folder
3. Right click under the folder in Explorer and choose Open in Command Prompt - if you have it. Some Windows versions removed this option from their context menu. If not, select Open in New Window, go to the File menu and select Open Command Prompt (as Administrator, if you can) from there
4. Write 'dotnet new console' in the console window, then close the command prompt and the Windows Explorer window, if you needed it
5. Select the newly created Code Hello World folder
6. From the open folder, open Program.cs
7. To the warning "Required assets to build and debug are missing from your project. Add them?" click Yes
8. To the info "There are unresolved dependencies from '<your project>.csproj'. Please execute the restore command to continue." click Restore
9. Click the Debug icon and press the green play arrow

10. Open project.json and add

    ,"Microsoft.AspNetCore.Server.Kestrel": "1.0.0"

    to dependencies (right after Microsoft.NETCore.App)
11. Open the .csproj file and add

    <ItemGroup>
        <PackageReference Include="Microsoft.AspNetCore" Version="1.1.1" />
      </ItemGroup>
    

12. Open Program.cs and change it by adding

    using Microsoft.AspNetCore.Hosting;

    and replacing the Console.WriteLine thing with

    var host = new WebHostBuilder()
                    .UseKestrel()
                    .UseStartup<Startup>()
                    .Build();
    host.Run();

13. Create a new file called Startup.cs that looks like this:

    using System;
    using Microsoft.AspNetCore.Builder;
    using Microsoft.AspNetCore.Hosting;
    using Microsoft.AspNetCore.Http;
    
    namespace <your namespace here>
    {
        public class Startup
        {
            public void Configure(IApplicationBuilder app)
            {
                app.Run(context =>
                {
                    return context.Response.WriteAsync("Hello from ASP.NET Core!");
                });
            }
        }
    }

#WhatHaveWeDone

Various useful things

Logging

"Microsoft.Extensions.Logging": "1.0.0"

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Logging;

namespace ConsoleApplication
{
    public class Startup
    {
        public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
        {
            var logger=loggerFactory.CreateLogger("Sample app logger");
            logger.LogInformation("Starting app");
        }
    }
}

{
  "version": "1.0.0-*",
  "buildOptions": {
    "debugType": "portable",
    "emitEntryPoint": true
  },
  "dependencies": {},
  "frameworks": {
    "netcoreapp1.0": {
      "dependencies": {
        "Microsoft.NETCore.App": {
          "type": "platform",
          "version": "1.0.0"
        },
        "Microsoft.AspNetCore.Server.Kestrel": "1.0.0",
        "Microsoft.Extensions.Logging": "1.0.0"
      },
      "imports": "dnxcore50"
    }
  }
}

"Microsoft.Extensions.Logging.Console": "1.0.0"

Static files

<PackageReference Include="Microsoft.AspNetCore.StaticFiles" Version="1.1.1" />

{
  "version": "1.0.0-*",
  "buildOptions": {
    "debugType": "portable",
    "emitEntryPoint": true
  },
  "dependencies": {},
  "frameworks": {
    "netcoreapp1.0": {
      "dependencies": {
        "Microsoft.NETCore.App": {
          "type": "platform",
          "version": "1.0.0"
        },
        "Microsoft.AspNetCore.Server.Kestrel": "1.0.0",
        "Microsoft.AspNetCore.StaticFiles": "1.0.0"
      },
      "imports": "dnxcore50"
    }
  }
}

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp1.1</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore" Version="1.1.1" />
    <PackageReference Include="Microsoft.AspNetCore.StaticFiles" Version="1.1.1" />
  </ItemGroup>

</Project>

using System.IO;
using Microsoft.AspNetCore.Hosting;

namespace ConsoleApplication
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var path=Path.Combine(Directory.GetCurrentDirectory(),"www");
            var host = new WebHostBuilder()
                .UseKestrel()
                .UseWebRoot(path)
                .UseStartup<Startup>()
                .Build();

            host.Run();
        }
    }
}

using Microsoft.AspNetCore.Builder;

namespace ConsoleApplication
{
    public class Startup
    {
        public void Configure(IApplicationBuilder app)
        {
            app.UseStaticFiles();
        }
    }
}

Routing

"Microsoft.AspNetCore.Routing": "1.0.0"

{
  "version": "1.0.0-*",
  "buildOptions": {
    "debugType": "portable",
    "emitEntryPoint": true
  },
  "dependencies": {},
  "frameworks": {
    "netcoreapp1.0": {
      "dependencies": {
        "Microsoft.NETCore.App": {
          "type": "platform",
          "version": "1.0.0"
        },
        "Microsoft.AspNetCore.Server.Kestrel": "1.0.0",
        "Microsoft.AspNetCore.Routing": "1.0.0"
      },
      "imports": "dnxcore50"
    }
  }
}

using Microsoft.AspNetCore.Hosting;

namespace ConsoleApplication
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var host = new WebHostBuilder()
                .UseKestrel()
                .UseStartup<Startup>()
                .Build();

            host.Run();
        }
    }
}

using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
using Microsoft.Extensions.DependencyInjection;

namespace ConsoleApplication
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddRouting();
        }

        public void Configure(IApplicationBuilder app)
        {
            app.UseRouter(new HelloRouter());
        }

        public class HelloRouter : IRouter
        {
            public VirtualPathData GetVirtualPath(VirtualPathContext context)
            {
                return null;
            }

            public Task RouteAsync(RouteContext context)
            {
                var requestPath = context.HttpContext.Request.Path;
                if (requestPath.StartsWithSegments("/hello", StringComparison.OrdinalIgnoreCase))
                {
                    context.Handler = async c =>
                    {
                        await c.Response.WriteAsync($"Hello world!");
                    };
                }
                return Task.FromResult(0);
            }
        }
    }
}

using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
using Microsoft.Extensions.DependencyInjection;

namespace ConsoleApplication
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddRouting();
        }

        public void Configure(IApplicationBuilder app)
        {
            var defaultHandler = new RouteHandler(
                c => c.Response.WriteAsync($"Default handler! Route values: {string.Join(", ", c.GetRouteData().Values)}")
            );

            var routeBuilder = new RouteBuilder(app, defaultHandler);

            routeBuilder.Routes.Add(new Route(new HelloRouter(), "hello/{name:alpha?}",
                    app.ApplicationServices.GetService<IInlineConstraintResolver>()));

            routeBuilder.MapRoute("Track Package Route",
                "package/{operation:regex(track|create|detonate)}/{id:int}");

            var router = routeBuilder.Build();
            app.UseRouter(router);
        }

        public class HelloRouter : IRouter
        {
            public VirtualPathData GetVirtualPath(VirtualPathContext context)
            {
                return null;
            }

            public Task RouteAsync(RouteContext context)
            {
                var name = context.RouteData.Values["name"] as string;
                if (String.IsNullOrEmpty(name)) name="World";

                var requestPath = context.HttpContext.Request.Path;
                if (requestPath.StartsWithSegments("/hello", StringComparison.OrdinalIgnoreCase))
                {
                    context.Handler = async c =>
                    {
                        await c.Response.WriteAsync($"Hi, {name}!");
                    };
                }
                return Task.FromResult(0);
            }
        }
    }
}

Error handling

"Microsoft.AspNetCore.Diagnostics": "1.0.0"

using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
using Microsoft.Extensions.DependencyInjection;

namespace ConsoleApplication
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddRouting();
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            app.UseDeveloperExceptionPage();
            app.UseStatusCodePages(/*context=>{
                throw new Exception($"Page return status code: {context.HttpContext.Response.StatusCode}");
            }*/);

            var defaultHandler = new RouteHandler(
                c => c.Response.WriteAsync($"Default handler! Route values: {string.Join(", ", c.GetRouteData().Values)}")
            );

            var routeBuilder = new RouteBuilder(app, defaultHandler);

            routeBuilder.Routes.Add(new Route(new HelloRouter(), "hello/{name:alpha?}",
                    app.ApplicationServices.GetService<IInlineConstraintResolver>()));

            routeBuilder.MapRoute("Track Package Route",
                "package/{operation:regex(track|create|detonate)}/{id:int}");

            var router = routeBuilder.Build();
            app.UseRouter(router);
        }

        public class HelloRouter : IRouter
        {
            public VirtualPathData GetVirtualPath(VirtualPathContext context)
            {
                return null;
            }

            public Task RouteAsync(RouteContext context)
            {
                var name = context.RouteData.Values["name"] as string;
                if (String.IsNullOrEmpty(name)) name = "World";
                if (String.Equals(name, "error", StringComparison.OrdinalIgnoreCase))
                {
                    throw new ArgumentException("Hate errors! Won't say Hi!");
                }

                var requestPath = context.HttpContext.Request.Path;
                if (requestPath.StartsWithSegments("/hello", StringComparison.OrdinalIgnoreCase))
                {
                    context.Handler = async c =>
                    {
                        await c.Response.WriteAsync($"Hi, {name}!");
                    };
                }
                return Task.FromResult(0);
            }
        }
    }
}

Final thoughts

• Trying out .NET Core and VS Code - Console Hello World
• ASP.Net Core with Visual Studio Code
• ASP.Net Core Web API with Visual Studio Code
• The default Core website with Visual Studio Code

Installation

1. Download and install the .NET Core SDK for Windows (if you want the complete Core, that works with Visual Studio, go here for more details. This is the freeware version of getting started :) )
2. Download and install Visual Studio Code which ironically needs .NET 4.5 to run.
3. After running Code, press Ctrl-P and in the textbox that appears write 'ext install csharp', wait for a dropdown to appear and click on the C# for Visual Studio Code (powered by Omnisharp) entry to install support for C#

Visual Studio Code overview

• Explorer - which opens up files and probably will show solutions
• Search - which helps you search within files
• Debug - I can only assume that it debugs stuff
• Git - So Git is directly integrated in the code editor, not "source control", just Git. It is an interesting statement to see Git as a first class option in the editor, while support for C# needs to be installed.

Hello world! - by ear

namespace CodeHelloWorld
{
    public class Program {
        static void Main(string[] args) {
            Console.WriteLine("Hello World!");
        }
    }
}

Hello world! - by tutorial

Hello world! - by Code

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": ".NET Core Launch (console)",
            "type": "coreclr",
            "request": "launch",
            "preLaunchTask": "build",
            "program": "${workspaceRoot}/bin/Debug/netcoreapp1.0/Code Hello World.dll",
            "args": [],
            "cwd": "${workspaceRoot}",
            "externalConsole": false,
            "stopAtEntry": false
        },
        {
            "name": ".NET Core Attach",
            "type": "coreclr",
            "request": "attach",
            "processId": 0
        }
    ]
}

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": ".NET Core Launch (console)",
            "type": "coreclr",
            "request": "launch",
            "preLaunchTask": "build",
            "program": "${workspaceRoot}/bin/Debug/<target-framework>/<project-name.dll>",
            "args": [],
            "cwd": "${workspaceRoot}",
            "stopAtEntry": false,
            "externalConsole": false
        },
        {
            "name": ".NET Core Launch (web)",
            "type": "coreclr",
            "request": "launch",
            "preLaunchTask": "build",
            "program": "${workspaceRoot}/bin/Debug/<target-framework>/<project-name.dll>",
            "args": [],
            "cwd": "${workspaceRoot}",
            "stopAtEntry": false,
            "launchBrowser": {
                "enabled": true,
                "args": "${auto-detect-url}",
                "windows": {
                    "command": "cmd.exe",
                    "args": "/C start ${auto-detect-url}"
                },
                "osx": {
                    "command": "open"
                },
                "linux": {
                    "command": "xdg-open"
                }
            },
            "env": {
                "ASPNETCORE_ENVIRONMENT": "Development"
            }
        },
        {
            "name": ".NET Core Attach",
            "type": "coreclr",
            "request": "attach",
            "processId": 0
        }
    ]
}

Debugging

Conclusion

• configurable interval for keeping a page open before bookmarking it for Read Later (so that all redirects and icons are loaded correctly)
• configurable interval after which deleted bookmarks are no longer remembered
• remembering deleted bookmarks no matter what deletes them
• more Read Later folders: configure their number and names
• redesigned options page
• more notifications on what is going on

var date1=new Date();
var date2=new Date(date1.getTime()); // now date2 points to the same moment in time as date1
console.log(date1==date2) // outputs "false"
date1=date2;
console.log(date1==date2) // outputs "true", date1 and date2 are pointing to the same object

jQuery.expr.filters.visible = function( elem ) {

    // Support: Opera <= 12.12
    // Opera reports offsetWidths and offsetHeights less than zero on some elements
    // Use OR instead of AND as the element is not visible if either is true
    // See tickets #10406 and #13132
    return elem.offsetWidth > 0 || elem.offsetHeight > 0 || elem.getClientRects().length > 0;
};

$.extend($.expr[':'], {
    nothidden : function (el) {
        el=$(el);
        while (el.length) {
            if (el[0].ownerDocument===null) break;
            if (el.css('display')=='none') return false;
            el=el.parent();
        }
        return true;
    }
});