README.html

<h1>dotNeTS</h1>

<p>.NET library-syntax for typescript/javascript</p>

<p>This library aims to implement the good parts of .Net-syntax in typescript/javascript.<br />
If you're new to javascript you'll have a hard time dealing with the functional style<br />
of programming often implemented in ex. lodash for dealing with data-operations.<br />
dotNeTS gives you lambda expressions and full implementation (soon) of System.Collection.Generics.</p>

<p>dotNeTS also aims to NOT reinvent the wheel and uses javascript 'best-choices' for data-mainpulation<br />
and functionality. e.g the List-implementation relies on lodash.</p>

<p>And <strong>YES</strong> right now, this library uses uppercase for methods, something that is frowned upon in javascript-world.<br />
I know about the dangers with the new-operator and binding this to global-object. But my defence is that dotNeTS soon<br />
will compile to two seperate libraries one with uppercase(.NET-ish) and one that passes jslint. And also,<br />
if you use typescript, it helps you avoid the new and this-pitfalls (some atleast). At the end of the day, you still need<br />
to know what you�re doing.</p>

<p>And <strong>YES</strong> I know all about <a href="http://linqjs.codeplex.com/">Linq.js</a>, but this library is much, much smaller<br />
and sits ontop of lodash. I built it to avoid having to pull in lodash and Linq.js in one of my latest projects.</p>

<p>dependencies:<br />
*   lodash</p>

<p>Install:</p>

<pre><code>bower install dotNeTS
</code></pre>

<p>IMPORTANT NOTE FOR Visual Studio! This library includes typescript definition AND source.<br />
You have to exclude one of them in VS to avoid duplicate definitions.</p>

<p>Example 1:</p>

<pre><code>    module app {
        interface User {
            id: number
            username: string;
        }
        export class UserManager {
            constructor() {
                //Import namespace
                var List = dotNeTS.List;

                //Random Data
                var user1: User = {
                    id: 1,
                    username: "olofd",
                };
                var user2: User = {
                    id: 2,
                    username: "ludde",
                };

                //Regular javascript array;
                var arrayOfUsers = [user1, user2];

                //Create List&lt;User&gt;
                var myList = new List&lt;User&gt;(arrayOfUsers);
                var userNameArray = myList.Where(b=&gt; b.id === 1).Select(b=&gt; b.username).ToArray();
                console.log(userNameArray);
                //=&gt; ['olofd']
            }
        }
    }
    var userMgr = new app.UserManager();
</code></pre>

<p>Example 2 (Actual code from project)                    </p>

<pre><code>var languagesAvailable = allLanguages.Where(s =&gt; !languagesAlreadyAdded.Where(es =&gt; es.LangCode === s.value).Any())
                        .Where(b =&gt; b.language &amp;&amp; b.language !== "")
                        .OrderBy(b =&gt; b.language)
                        .ThenBy(b =&gt; b.country);
return languagesAvailable.ToArray();
</code></pre>

<p>Example 3 (Actual code from project)   </p>

<pre><code>var languagesAvailable = allLanguages.Where(s =&gt; !languagesAlreadyAdded.Where(es =&gt; es.LangCode === s.value).Any())
                        .GroupBy(b =&gt; b.country)
return languagesAvailable.Where(b =&gt; b.Key === 'Sweden').ToList();
</code></pre>

<p>Interfaces with underlying implementations:<br />
(* all implementations have tests.)</p>

<pre><code>module dotNeTS {
    export interface IEnumerable&lt;TSource&gt; extends IDisposable {
        ForEach(callback: dotNeTS.IFunc&lt;TSource, void&gt;): void
        Contains(item: TSource): boolean;
        GroupBy&lt;TResult&gt;(callback: IFunc&lt;TSource, TResult&gt;): IEnumerable&lt;IGrouping&lt;TResult, TSource&gt;&gt;;
        OrderBy&lt;TKey&gt;(keySelector: dotNeTS.IFunc&lt;TSource, TKey&gt;): IOrderedEnumerable&lt;TSource&gt;;
        OrderByDecending&lt;TKey&gt;(callback: IFunc&lt;TSource, TKey&gt;): IOrderedEnumerable&lt;TSource&gt;;
        First(predicate?: IFunc&lt;TSource, boolean&gt;): TSource;
        FirstOrDefault(predicate?: IFunc&lt;TSource, boolean&gt;): TSource;
        Single(predicate?: IFunc&lt;TSource, boolean&gt;): TSource;
        SingleOrDefault(predicate?: IFunc&lt;TSource, boolean&gt;): TSource;
        Any(predicate?: IFunc&lt;TSource, boolean&gt;): boolean;
        Count(predicate?: IFunc&lt;TSource, boolean&gt;): number;
        Select&lt;TResult&gt;(callback: IFunc&lt;TSource, TResult&gt;): IEnumerable&lt;TResult&gt;;
        Where(predicate?: IFunc&lt;TSource, boolean&gt;): IEnumerable&lt;TSource&gt;;
        ToArray(): TSource[];
        ToList(): IList&lt;TSource&gt;;
    }
}

module dotNeTS {
    export interface IOrderedEnumerable&lt;TSource&gt; extends IEnumerable&lt;TSource&gt; {
        OrderBy&lt;TKey&gt;(keySelector: IFunc&lt;TSource, TKey&gt;): IOrderedEnumerable&lt;TSource&gt;;
        OrderByDecending&lt;TSort&gt;(callback: IFunc&lt;TSource, TSort&gt;): IOrderedEnumerable&lt;TSource&gt;;
        ThenBy&lt;TSort&gt;(callback: IFunc&lt;TSource, TSort&gt;): IOrderedEnumerable&lt;TSource&gt;;
        ThenByDecending&lt;TSort&gt;(callback: IFunc&lt;TSource, TSort&gt;): IOrderedEnumerable&lt;TSource&gt;;
    }
} 
module dotNeTS {
    export interface IList&lt;TSource&gt; extends IEnumerable&lt;TSource&gt;{
        Add(item: TSource): void;
        AddRange(collection: IEnumerable&lt;TSource&gt;): void;
        Remove(item: TSource): void;
        RemoveAt(index: number);
        Clear():void;
        Contains(item : TSource) : boolean;
        IndexOf(item: TSource) : number;
        Insert(index: number, item: TSource) : void;
    }
}
module dotNeTS {
    export interface IGrouping&lt;TKey, TElement&gt; extends IEnumerable&lt;TElement&gt;{
        Key: TKey;
    }
}
</code></pre>