http://www.c-sharpcorner.com/UploadFile/mahesh/what-is-new-in-C-Sharp-6-0/

Recently, I got a question in an email asking how to load an XML file and display it on the system console.

We can use XmlDocument to read an XML document. The Load method is used to load an XML into an XmlDocument. Once a document is loaded, we can use the Save method to display its content to the console. The key is, passing Console.Out as a parameter.

XmlDocument xmlDoc = new XmlDocument();

string filename = @"C:\Books\Books.xml";           

xmlDoc.Load(filename);

xmlDoc.Save(Console.Out);

You must import the System.Xml namespace in your code. 

Although DataContext/ObjectContext implement IDisposable, you can (in general)

get away without disposing instances. Disposing forces the context’s connection

to dispose—but this is usually unnecessary because L2S and EF close connections

automatically whenever you finish retrieving results from a query.

Disposing a context can actually be problematic because of lazy evaluation. Con-

sider the following:

IQueryable<Customer> GetCustomers (string prefix)

{

  using (var dc = new NutshellContext ("connection string"))

    return dc.GetTable<Customer>()

             .Where (c => c.Name.StartsWith (prefix));

}

...

foreach (Customer c in GetCustomers ("a"))

  Console.WriteLine (c.Name);

This will fail because the query is evaluated when we enumerate it—which is

after disposing its DataContext.

There are some caveats, though, on not disposing contexts:

• It relies on the connection object releasing all unmanaged resources on the

Close method. While this holds true with SqlConnection, it’s theoretically

possible for a third-party connection to keep resources open if you call

Close but not Dispose (though this would arguably violate the contract de-

fined by IDbConnection.Close).

• If you manually call GetEnumerator on a query (instead of using foreach) and

then fail to either dispose the enumerator or consume the sequence, the con-

nection will remain open. Disposing the DataContext/ObjectContext provides

a backup in such scenarios.

• Some people feel that it’s tidier to dispose contexts (and all objects that im-

plement IDisposable).

If you want to explicitly dispose contexts, you must pass a DataContext/Object

Context instance into methods such as  GetCustomers to avoid the problem

described.

요즘 활용하려고 하는 데이터베이스 형태.

열라 쉽다. 다만 셋팅에서 아직 곤혹을 느끼고 있다.

ADO.NET Entity Data Model.pdf

Entity Data 글자대로 봐서는,

관련 테이블마다 따로따로 사용하길 바라는 목적에서 만든 것 같다.

원본: http://www.c-sharpcorner.com/UploadFile/rmcochran/functional-programming-in-C-Sharp-currying/

Currying a method call breaks the single method into a chain of methods. Let's start with the a very simple method transformation as an example of what we will be doing.  If we have a method defined with one input and one output as follows:

Func<Int32, Int32> SubtractOne = x => x - 1;

We can call this normally as

SubtractOne(8);

If the method was tranformed to return a delegate with a single input parameter, we would be able to call it a bit differently

SubtractOne.Curry()(8)

How do we build our simplified Curry() method transformation?  It's very simple utility method that we can use to modify any type of function with one argument that will return a delegate:

public static Func<TInput1, TOutput> Curry<TInput1, TOutput>(this Func<TInput1, TOutput> f)
{
    return x => f(x);
}

Pretty simple concept... right?  In reality, we probably wouldn't really curry a function with only one input parameter because the whole point is to get the arguments down to one tastey argument per delegate "call", but hopefully this sample helps you understand how we will begin to spice up our methods with curry.

Ultimately we would like to be able to curry a method with multiple input parameters as follows:

Func<Int32, Int32, Int32, Int32, Int32>
    Add = (w, x, y, z) => w + x + y + z;

Console.WriteLine(Add(1, 2, 3, 4));             // Normal call
Console.WriteLine(Add.Curry()(1)(2)(3)(4));     // Curried Call

And we just need a library of utility methods that curry (and uncurry) multi-argument methods.  All the samples are in the code accompanying this article, but here is the Curry() method for the 4-argument input method.  At first, it's kind of painful to look at, but if you look at the other Curry() methods in the accompanying code.. itshould be pretty much self-explanatory. On the "outer shell" we have a delegate that takes a single input and returns another delegate (which takes a single input and returns another delegate... (and so on... and so on...)). So as a result we esentially have 4 "nested" delegates.

public static Func<TInput1, Func<TInput2, Func<TInput3, Func<TInput4, TOutput>>>> 
    Curry<TInput1, TInput2, TInput3, TInput4, TOutput>
    (
       this Func<TInput1, TInput2, TInput3, TInput4, TOutput> f
    )
{
    return w => x => y => z => f(w, x, y, z);
}

Now for the big question "Why the heck would you want to do that?". 

Using this currying technique gives us a different syntax more conducive to building up a library of complex composite functions from simpler functions.  For a (very(very)) simple example... if we wanted a function that computed the cubic area of a box, we could construct it from a simpler "Multiply" function as follows:

    Func<Int32, Int32, Int32> Multiply = (x, y) => x * y;

    Func<Int32, Int32, Int32, Int32>
        CubicArea = (length, width, height) => Multiply.Curry()(Multiply(length, width))(height);

    Console.WriteLine("The cubic area is: " + CubicArea(2, 3, 4).ToString());

We could also use currying to reduce the number of input parameters.  For example, if we wanted to find the cubic area of a perfectly square cube we could use currying to combine the input parameters.

Func<Int32, Int32>
    PerfectCubeArea = (length) => Multiply.Curry()(Multiply(length, length))(length);

As you can see, currying is really nothing more than a different syntax for calling our already existing methods.  However, this powerful technique becomes more and more useful when we get into complex computations and want to build functionality from a composite tree perspective.

I hope you enjoy currying up your C# methods (which are especially tastey with coconut milk and shrimp).

Until next time,
Happy coding

VS2010_VisualCshap_shortcut.pdf