I managed to write my own implementation that do automatic reconnects on this new version of .NET Core 2 SignalR that works for me.

The code bellow uses Polly for automatic retry policy and Serilog for logging.

Here is my implementation. Hope someone will find it useful:

var signalRConnection = new HubConnectionBuilder()
     .WithUrl(BaseUrl + "/hubs/integrationserver", options =>
     {
      options.Headers.Add("Authorization", "Basic " + Header);
     }).Build();
signalRConnection.On<string, string>("ReceiveMessage", (entityName, json) =>
{

       
});

private async void OpenSignalRConnection()
{

     var pauseBetweenFailures = TimeSpan.FromSeconds(20);
     var retryPolicy = Policy
         .Handle<Exception>()
         .WaitAndRetryForeverAsync(i => pauseBetweenFailures
         , (exception, timeSpan) => {
             Log.Error(exception.ToString());
         });

     await retryPolicy.ExecuteAsync(async () =>
     {
         Log.Information("Trying to connect to SignalR server");
         await TryOpenSignalRConnection();
     });
}

private async Task<bool> TryOpenSignalRConnection()
{
     Log.Information("Starting SignalR connection");
     await signalRConnection.StartAsync();

     Log.Information("SignalR connection established");

     return true;

}

private async Task SignalRConnection_Closed(Exception arg)
{

     Log.Information("SignalR connection is closed");
     await signalRConnection.StopAsync();
     signalRConnection.Closed -= SignalRConnection_Closed;

     OpenSignalRConnection();

}

The post .NET Core SignalR Automatic Reconnects appeared first on RadenkoZec blog.

The problem is that you sometimes need a validation on these hidden fields.

However there is a nice workaround.

Make sure to put

$.validator.setDefaults({ ignore: '' });

not inside

$(document).ready

This will force client side validation to work even on hidden fields.

But what if you change value of hidden input from JQuery and want validation to perform after this change?

The code above will not help in this case.

I will show you a nice trick for this on example hidden input #SomeInput :

 $("#SomeInput").val("newValue").trigger("change");
 $("#SomeInput").valid();

We must call method valid after apply change to hidden input to force validation to perform after manually changing hidden input value.

If you like this article don’t forget to subscribe to this blog and make sure you don’t miss new upcoming blog posts.

The post Enable Unobtrusive JQuery Validation on Hidden Input Fields in ASP.NET MVC appeared first on RadenkoZec blog.

<configuration>
  <appSettings>  
    <add key="ClientValidationEnabled" value="true" />
    <add key="UnobtrusiveJavaScriptEnabled" value="true" />
  </appSettings>
</configuration>

In ASP.NET MVC 6 process of enabling client side validation is even more simpler.

On views you want to enable unobtrusive client side validation just include:

@section scripts{
    @{await Html.RenderPartialAsync("_ValidationScriptsPartial"); }
}

I hope this small blog post will help someone to save some time creating awesome ASP.NET MVC 6 apps.

If you like this article don’t forget to subscribe to this blog and make sure you don’t miss new upcoming blog posts.

The post How to enable Unobtrusive Client Validation using JQuery in ASP.NET 5 appeared first on RadenkoZec blog.

When you finish configuring Aurelia app files to reside in wwwroot folder of your ASP.NET 5 application you can run Aurelia app easily by typing for example http://localhost:5000/index.html

The problem is if you want to mix ASP.NET MVC 6 app with Aurelia.

I need to have several ASP.NET MVC 6 views like Login and Registration in my Web app and after login to redirect users to Aurelia app.

In ASP.NET MVC 6 app I have a URL like this: http://localhost:5000/Account/Login and I want to my Aurelia app have a URL like this: http://localhost:5000/Aurelia .

If you want to use razor views there is a nice workaround for that in official Aurelia docs.

If you want to use regular HTML files like me follow this simple tutorial.

Easiest way to do this is to redirect users to a controller which will return Aurelia app:

    public class AureliaController : Controller
    {
        private readonly IApplicationEnvironment _hostingEnvironment;
        public AureliaController(IApplicationEnvironment hostingEnvironment)
        {
            _hostingEnvironment = hostingEnvironment;
        }
        public IActionResult Index()
        {
            var path = _hostingEnvironment.ApplicationBasePath + "\\wwwroot\\index.html";

            if (System.IO.File.Exists(path))
            {
                return File(path, "text/html");
            }
            return HttpNotFound();
        }
    }

You need to name the controller properly. For a route http://localhost:5000/Aurelia you need to name it  AureliaController.

IApplicationEnvironment is automatically injected in the constructor by ASP.NET 5 so we can access ApplicationBasePath variable.

Index method will return File result with Aurelia root application file in this case index.html.

So my resulted route will be http://localhost:5000/Aurelia and when I navigate using a router to another view like http://localhost:5000/Aurelia#welcome my routes are persisted and not changed to http://localhost:5000/index.html.

I hope this tutorial will help someone to jump start with AureliaJs in Visual Studio 2015.

If you like this article don’t forget to subscribe to this blog and make sure you don’t miss new upcoming blog posts.

The post Getting user-friendly routes with Aurelia in ASP.NET 5 appeared first on RadenkoZec blog.

First, you will need to create .NET core class library project to hold your integration tests:

After this you will need to set-up XUnit.net.

Check my previous blog post to do that.

After this create a folder named Data in your test project. In this folder you will need to put SQL script GenerateDb.sql (without create a database statement) which will create all objects in the database.

Put this LocalDb class somewhere in the project.

 public static class LocalDb
    {
        public const string DbDirectory = "Data";

        public static void CreateLocalDb(string databaseName, string scriptName, bool deleteIfExists = false)
        {
            string codeBase = Assembly.GetExecutingAssembly().CodeBase;
            UriBuilder uri = new UriBuilder(codeBase);
            string path = Uri.UnescapeDataString(uri.Path);
           // return Path.GetDirectoryName(path);

            string outputFolder = Path.Combine(Path.GetDirectoryName(path), DbDirectory);
            string mdfFilename = databaseName + ".mdf";
            string databaseFileName = Path.Combine(outputFolder, mdfFilename);

            // Create Data Directory If It Doesn't Already Exist.
            if (!Directory.Exists(outputFolder))
            {
                Directory.CreateDirectory(outputFolder);
            }

            if (CheckDatabaseExists(databaseName) && deleteIfExists)
            {
                DropDatabaseObjects(databaseName);
            }
            else if (!CheckDatabaseExists(databaseName))
            {
                // If the database does not already exist, create it.
                CreateDatabase(databaseName, databaseFileName);
            }
            if (deleteIfExists)
            {
                ExecuteScript(databaseName, scriptName);
            }
        }

        private static void ExecuteScript(string databaseName, string scriptName)
        {
            string connectionString = string.Format(@"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog={0};Integrated Security=True", databaseName);

            string codeBase = Assembly.GetExecutingAssembly().CodeBase;
            UriBuilder uri = new UriBuilder(codeBase);
            string path = Uri.UnescapeDataString(uri.Path);

            string outputFolder = Path.Combine(Path.GetDirectoryName(path), DbDirectory);
            string scriptPath = Path.Combine(outputFolder, scriptName);

            var file = new FileInfo(scriptPath);
            string script = file.OpenText().ReadToEnd();

            string[] commands = script.Split(new[] { "GO\r\n", "GO ", "GO\t" }, StringSplitOptions.RemoveEmptyEntries);

            using (var connection = new SqlConnection(connectionString))
            {
                connection.Open();
                foreach (string c in commands)
                {
                    var command = new SqlCommand(c, connection);
                    command.ExecuteNonQuery();
                }
            }
        }

        private static bool CheckDatabaseExists(string databaseName)
        {
            string connectionString = string.Format(@"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=master;Integrated Security=True;Connection Timeout=300");
            using (var connection = new SqlConnection(connectionString))
            {
                connection.Open();
                SqlCommand cmd = connection.CreateCommand();

                cmd.CommandText = string.Format("SELECT name FROM master.dbo.sysdatabases WHERE ('[' + name + ']' = '{0}' OR name = '{1}')", databaseName, databaseName);
                object result = cmd.ExecuteScalar();
                if (result != null)
                {
                    return true;
                }
            }

            return false;
        }

        private static void DropDatabaseObjects(string databaseName)
        {
            try
            {
                string connectionString = string.Format(@"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog={0};Integrated Security=True;Connection Timeout=300", databaseName);

                using (var connection = new SqlConnection(connectionString))
                {
                    connection.Open();
                    var commandSetSingle = new SqlCommand(@"declare @ord int, @cmd varchar(8000)

                    declare objs cursor for
                    select 0, 'drop trigger [' + name + '] on database' from sys.triggers
                    where parent_class = 0 and is_ms_shipped = 0
                    union
                    select 1, 'drop synonym [' + schema_name(schema_id) + '].[' + name + ']' from sys.objects o
                    where o.type = 'SN'
                    union
                    select 2, 'drop procedure [' + schema_name(schema_id) + '].[' + name + ']' from sys.objects o
                    where o.type = 'P'
                    union
                    select 3, 'drop view [' + schema_name(schema_id) + '].[' + name + ']' from sys.objects o
                    where o.type = 'V'
                    union
                    select 4, 'drop function [' + schema_name(schema_id) + '].[' + name + ']' from sys.objects o
                    where o.type IN ('FN','IF', 'TF')
                    union
                    select 5, 'alter table [' + schema_name(schema_id) + '].[' + object_name(parent_object_id) + '] drop constraint [' + name + ']'
                    from sys.objects
                    where type = 'F'
                    union
                    select 6, 'drop table [' + schema_name(schema_id) + '].[' + name + ']' from sys.objects o
                    where o.type = 'U'
                    union
                    select 7, 'drop type [' + schema_name(schema_id) + '].[' + name + ']' from sys.types
                    where is_user_defined = 1
                    union
                    select 8, 'drop default [' + schema_name(schema_id) + '].[' + name + ']' from sys.objects o
                    where o.type = 'D'
                    order by 1

                    open objs
                    fetch next from objs into @ord, @cmd

                    while @@FETCH_STATUS = 0
                    begin
                      print @cmd
                      execute (@cmd)
                      fetch next from objs into @ord, @cmd
                    end

                    close objs
                    deallocate objs",
                                    connection);
                    commandSetSingle.ExecuteNonQuery();
                }
            }
            catch
            {
            }
        }



        private static void CreateDatabase(string databaseName, string databaseFileName)
        {
            string connectionString = string.Format(@"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=master;Integrated Security=True");
            using (var connection = new SqlConnection(connectionString))
            {
                connection.Open();
                SqlCommand cmd = connection.CreateCommand();

                // TryDetachDatabase(databaseName);
                cmd.CommandText = string.Format("CREATE DATABASE {0} ON (NAME = N'{0}', FILENAME = '{1}')", databaseName, databaseFileName);
                cmd.ExecuteNonQuery();
            }
        }
}

Please be aware that in ASP.NET 5 LocalDb connection string is changed and version numbering (v11) is removed.

You will also need ItemDeployment to deploy script file into proper locations like in previous version of Visual Studio.

 internal static class ItemDeployment
    {
        public static void DeployItems(IEnumerable items, bool retainDirectories = false)
        {
            var environmentDir = new DirectoryInfo(Directory.GetCurrentDirectory());
            var binFolderPath = GetDeploymentDirectory();

            foreach (var item in items)
            {
                if (string.IsNullOrWhiteSpace(item))
                {
                    continue;
                }

                string dirPath = retainDirectories ? Path.GetDirectoryName(item) : "";
                var filePath = item.Replace("/", @"\");
                if (environmentDir.Parent != null)
                {

                    UriBuilder uri = new UriBuilder(environmentDir.FullName);
                    string path = Uri.UnescapeDataString(uri.Path);

                    var itemPath = new Uri(Path.Combine(Path.GetDirectoryName(path), filePath)).LocalPath;
                    if (!File.Exists(itemPath))
                    {
                        throw new FileNotFoundException(string.Format("Can't find deployment source item '{0}'", itemPath));
                    }

                    if (!Directory.Exists(binFolderPath))
                    {
                        throw new DirectoryNotFoundException(
                            string.Format("Deployment target directory doesn't exist: '{0}'", binFolderPath));
                    }

                    var dirPathInBin = Path.Combine(binFolderPath, dirPath);
                    if (!Directory.Exists(dirPathInBin))
                    {
                        Directory.CreateDirectory(dirPathInBin);
                    }

                    var itemPathInBin =
                        new Uri(Path.Combine(binFolderPath, dirPath, Path.GetFileName(filePath))).LocalPath;
                    if (!File.Exists(itemPathInBin))
                    {
                        File.Copy(itemPath, itemPathInBin);
                        File.SetAttributes(itemPath, FileAttributes.Normal);

                    }
                    else
                    {
                        var hash1 = ComputeFileHash(itemPath);
                        var hash2 = ComputeFileHash(itemPathInBin);
                        string hash1String = BitConverter.ToString(hash1);
                        string hash2String = BitConverter.ToString(hash2);

                        if (!hash1String.Equals(hash2String))
                        {

                            File.Copy(itemPath, itemPathInBin ,true);
                            File.SetAttributes(itemPath, FileAttributes.Normal);
                        }
                    }
                }
            }
        }

        public static byte[] ComputeFileHash(string fileName)
        {
            using (var stream = File.OpenRead(fileName))
                return System.Security.Cryptography.MD5.Create().ComputeHash(stream);
        }

        public static string GetDeploymentDirectory()
        {
            string codeBase = Assembly.GetExecutingAssembly().CodeBase;
            UriBuilder uri = new UriBuilder(codeBase);
            string path = Uri.UnescapeDataString(uri.Path);
            return Path.GetDirectoryName(path);
        }
    }
}

In constructor of your test class you just need to put Database name and script name for generating your LocalDb database.

We have implemented hash checking when copying files to avoid problems with multiple threads trying to copy same file.

public class TestClass
{
public TestClass()
{
     ItemDeployment.DeployItems(
               new[]
                {
                     @"ProjectName\FolderName\GenerateDb.sql"
                }, true);
     LocalDb.CreateLocalDb("Mydatabase", "GenerateDb.sql", true);
}
[Fact]
public void InsertPerson_AcceptCorrectParameters_InsertSuccess()
{
// write your database test
}

}

You will probably need to disable running XUnit.Net tests in multiple threads to avoid dirty checks in database tests.

If you like this article don’t forget to subscribe to this blog and make sure you don’t miss new upcoming blog posts.

The post LocalDB for Database Integration Testing in ASP.NET 5 project and XUnit.net appeared first on RadenkoZec blog.

If you create MSTest project you are unable to add a reference to the ASP.NET vNext project.

Microsoft will enable support for MSTests for ASP.NET vNext in the next release of Visual Studio.

Until then you can only write unit and integration tests using XUnit.

First, you will need to create .NET core class library project where you will have all your tests:

Reference vNext project or any other .NET project (you can reference regular .NET projects from vNext Class Library) you want to test.

Create your test class and test method similar to this:

public class TestClass
{ 
 [Fact]
 public void PassingTest()
 {
     Assert.Equal(3, 2);
 }
}

Add reference to these 3 NuGet packages:

"xunit": "2.1.0.0-beta1-build2945",
"xunit.runner.aspnet": "2.1.0.0-beta1-build60",
"xunit.runner.visualstudio": "2.1.0.0-beta1-build1051"

Make sure Test Explorer is visible ( Test > Windows > Test Explorer).

Every time you build your project, XUnit.Net will discover unit tests in your project.

Now you can run or debug your unit or integration tests.

If you like this article don’t forget to subscribe to this blog and make sure you don’t miss new upcoming blog posts.

The post Unit / Integration testing in ASP.NET 5 and Visual Studio 2015 using XUnit.Net appeared first on RadenkoZec blog.

In this post I will try to explain how to fix some common issues with using ADO.NET in ASP.NET vNext.

If you have created ASP.NET 5 or ASP.NET vNext Class Library project (.NET Core Class Library project) and want to use ADO.NET you can have small issues.

Instead of referencing System.Data and System.Data.SqlClient you need to grab from Nuget:

System.Data.Common and System.Data.SqlClient.

Currently this creates dependency in project.json –> aspnetcore50 section to these two libraries.

 "aspnetcore50": {
            "dependencies": {
                "System.Runtime": "4.0.20-beta-22523",
                "System.Data.Common": "4.0.0.0-beta-22605",
                "System.Data.SqlClient": "4.0.0.0-beta-22605"
            }
        }

In the current Visual Studio CTP6 after this your ADO.NET still will not compile.

You will need to add a reference to System.Data.Common 1.0.0-beta1 and System.Data.SqlClient into aspnet50 section of project.json like this:

 "aspnet50": {
            "dependencies": {
                "System.Data.Common": "1.0.0-beta1",
                "System.Data.SqlClient": "1.0.0-beta1"
            }
        }

I have also created little SqlHelper that works with ASP.NET 5 :

  public sealed class SqlHelper
    {
        //Since this class provides only static methods, make the default constructor private to prevent 
        //instances from being created with "new SqlHelper()".
        private SqlHelper()
        {

        }

        private static string connectionString;
        public static string GetConnectionString()
        {
            if (string.IsNullOrEmpty(connectionString))
            {
                var config = new Configuration()
                      .AddJsonFile("config.json")
                      .AddEnvironmentVariables();
                connectionString = config.Get("Data:DefaultConnection:ConnectionString");
            }

            return connectionString;
        }

        public static int ExecuteNonQuery(SqlConnection conn, string cmdText, SqlParameter[] cmdParms)
        {
            SqlCommand cmd = conn.CreateCommand();
            using (conn)
            {
                PrepareCommand(cmd, conn, null, CommandType.Text, cmdText, cmdParms);
                int val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                return val;
            }
        }

        public static int ExecuteNonQuery(SqlConnection conn, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
        {
            SqlCommand cmd = conn.CreateCommand();
            using (conn)
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
                int val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                return val;
            }
        }


        public static SqlDataReader ExecuteReader(SqlConnection conn, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
        {
            SqlCommand cmd = conn.CreateCommand();
            PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
            var rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            return rdr;
        }


        public static object ExecuteScalar(SqlConnection conn, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
        {
            SqlCommand cmd = conn.CreateCommand();
            PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
            object val = cmd.ExecuteScalar();
            cmd.Parameters.Clear();
            return val;
        }

        private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] commandParameters)
        {
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            if (trans != null)
            {
                cmd.Transaction = trans;
            }
            cmd.CommandType = cmdType;
            //attach the command parameters if they are provided
            if (commandParameters != null)
            {
                AttachParameters(cmd, commandParameters);
            }
        }
        private static void AttachParameters(SqlCommand command, SqlParameter[] commandParameters)
        {
            foreach (SqlParameter p in commandParameters)
            {
                //check for derived output value with no value assigned
                if ((p.Direction == ParameterDirection.InputOutput) && (p.Value == null))
                {
                    p.Value = DBNull.Value;
                }

                command.Parameters.Add(p);
            }
        }
    }

After this working with ADO.NET inside ASP.NET vNext is pretty straightforward:

 public class LogRepository
    {
        public void Add(Log log)
        {

            var parameters = new[]
                    {
                        new SqlParameter("@JobId", log.JobId),
                        new SqlParameter("@ErrorInfo", log.ErrorInfo),
                        new SqlParameter("@DateTimeProcessedUTC", log.DateTimeProcessedUTC)
                    };

            using (var conn = new SqlConnection(SqlHelper.GetConnectionString()))
            {
                     SqlHelper.ExecuteNonQuery(
                        conn,
                        CommandType.Text,
                        @" INSERT dbo.Log ([JobId],[ErrorInfo],[DateTimeProcessedUTC])
                            SELECT @JobId, @ErrorInfo, @DateTimeProcessedUTC"
                          ,
                        parameters);

            }

        }
    }
}

If you like this article don’t forget to subscribe to this blog and make sure you don’t miss new upcoming blog posts.

The post Using classic ADO.NET in ASP.NET 5 appeared first on RadenkoZec blog.

With the new version of ASP.NET more than one file type is supported.

Currently, there are 3 different file types that are supported: Json, Xml and Ini.

For example, we can define connection string in config.json file:

{
    "Data": {
        "DefaultConnection": { 
            "ConnectionString": "Server=(localdb)\\mssqllocaldb;Database=DbName;Trusted_Connection=True;MultipleActiveResultSets=true"
        }
    }
}

You can also get  settings from Environment Variables.

To read connection string from config.json from any location in your app you need to add a reference to Microsoft.Framework.ConfigurationModel.Json.

Now simple import namespace and use code below to read connection string from config.json:

using Microsoft.Framework.ConfigurationModel.Json;

var configuration = new Configuration()
                .AddJsonFile("config.json")
                .AddEnvironmentVariables();

var connectionString = configuration.Get("Data:DefaultConnection:ConnectionString");

You can also load configuration from multiple different config files:

  var configuration = new Configuration()
                              .AddJsonFile("config.json")
                              .AddIniFile("config.ini")
                              .AddXmlFile("config.xml")
                              .AddEnvironmentVariables();

To use xml files you need to reference Microsoft.Framework.ConfigurationModel.Xml and for Ini Microsoft.Framework.ConfigurationModel.

Supporting multiple config files and reading values from config files has never been easier.

If you like this article don’t forget to subscribe to this blog and make sure you don’t miss new upcoming blog posts.

The post Read Config file in ASP.NET 5 appeared first on RadenkoZec blog.

Default ASP.NET Identity provider uses Entity Framework and SQL Server to store information’s about users.

If you are trying to implement ASP.NET Identity 2.1 for MySQL database, then follow this guide.

This implementation uses Oracle fully-managed ADO.NET driver for MySQL.

This means that you have a connection string in your web.config similar to this:

<add name="DefaultConnection" connectionString="Server=localhost;
Database=aspnetidentity;Uid=radenko;Pwd=somepass;" providerName="MySql.Data.MySqlClient" />

This implementation of ASP.NET Identity 2.1 for MySQL has all the major interfaces implemented in custom UserStore class:

Source code of my implementation is available at GitHub – MySqlIdentity

First, you will need to execute this a create script on your MySQL database which will create the tables required for the ASP.NET Identity provider.

• Create a new ASP.NET MVC 5 project, choosing the Individual User Accounts authentication type.
• Uninstall all EntityFramework NuGet packages starting with Microsoft.AspNet.Identity.EntityFramework
• Install NuGet Package called MySql.AspNet.Identity
• In ~/Models/IdentityModels.cs:
  • Remove the namespaces:
    • Microsoft.AspNet.Identity.EntityFramework
    • System.Data.Entity
  • Add the namespace: MySql.AspNet.Identity.
    Class ApplicationUser will inherit from IdentityUser class in MySql.Asp.Net.Identity namespace
  • Remove the entire ApplicationDbContext class. This class is not needed anymore.
• In ~/App_Start/Startup.Auth.cs
  • Delete this line of code

app.CreatePerOwinContext(ApplicationDbContext.Create);

• In ~/App_Start/IdentityConfig.cs
  Remove the namespaces:
  • Microsoft.AspNet.Identity.EntityFramework
  • System.Data.Entity
• In method Create inside ApplicationUserManager class replace ApplicationUserManager with another which accepts MySqlUserStore :

 public static ApplicationUserManager Create(IdentityFactoryOptions<ApplicationUserManager> options, IOwinContext context) 
 {
     //var manager = new ApplicationUserManager(new UserStore<ApplicationUser>(context.Get<ApplicationDbContext>()));
        var manager = new ApplicationUserManager(new MySqlUserStore<ApplicationUser>());

MySqlUserStore accepts an optional parameter in the constructor – connection string so if you are not using DefaultConnection as your connection string you can pass another connection string.

After this you should be able to build your ASP.NET MVC project and run it successfully using MySQL as a store for your user, roles, claims and other information’s.

If you like this article don’t forget to subscribe to this blog and make sure you don’t miss new upcoming blog posts.

The post ASP.NET Identity 2.1 implementation for MySQL appeared first on RadenkoZec blog.

I wanted to share my experience with you.

After reading few non-fiction books in short period of time I have realized that only a fraction of the information in these books is important.

If we apply the Pareto principle to this:

20% of Non-Fiction book produce 80% value of the book. or

Only 20% content inside Non-Fiction book is valuable.

If that is true, why we bother reading non-fiction at all?

All we need to do is to get important information’s from the book.

How to get only valuable information’s from non-fiction book?

We live in a digital age where it’s easy to find what’s important in any popular book.

We can easily find lot of summaries in different forms: blog posts, videos, slideshare presentations etc.

Here are some great examples of that from popular books:

or

or

http://charlesholmes.net/2013/05/summary-of-rich-dad-poor-dad/

What to do instead of reading non-fiction books?

We actually read entire book thinking that working hard on reading will benefit us in the way we will remember more important information’s from the book.

If we easily get the info’s without facts to support these information’s we will not remember it as important information’s.

I think that I need to focus more on practicing, teaching and writing about important information’s from non-fiction books.

Just reading books, even with taking notes will not do it.

Selective ignorance of information’s

Also great example of nice visual summary of book: 4 hour work week visual summary

I also agree with Tim Ferris about low information diet, but only after a certain age.

I think we should selectively ignore information’s (this includes non-fiction books) which we don’t need today.

Practicing this too early in life can have negative results.

Reading fiction books

I am a big believer that reading fiction books, improve creativity, innovativity and intelligence.

Cognitive psychologist and fiction writer, Dr. Keith Oatley and other researchers have discovered that fiction activates and improves the cognitive functions that allow us to thrive socially.

So I’ll try to read more fiction books in the next period.

If you like this article don’t forget to subscribe to this blog and make sure you don’t miss new upcoming blog posts.

The post Don’t read Non-Fiction, never! appeared first on RadenkoZec blog.