Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/olofd/dotnets2

New itteration of DotNeTS
https://github.com/olofd/dotnets2

Last synced: about 2 months ago
JSON representation

New itteration of DotNeTS

Awesome Lists containing this project

README 

        

dotNeTS



.NET library-syntax for typescript/javascript



This library aims to implement the good parts of .Net-syntax in typescript/javascript.


If you're new to javascript you'll have a hard time dealing with the functional style


of programming often implemented in ex. lodash for dealing with data-operations.


dotNeTS gives you lambda expressions and full implementation (soon) of System.Collection.Generics.



dotNeTS also aims to NOT reinvent the wheel and uses javascript 'best-choices' for data-mainpulation


and functionality. e.g the List-implementation relies on lodash.



And YES right now, this library uses uppercase for methods, something that is frowned upon in javascript-world.


I know about the dangers with the new-operator and binding this to global-object. But my defence is that dotNeTS soon


will compile to two seperate libraries one with uppercase(.NET-ish) and one that passes jslint. And also,


if you use typescript, it helps you avoid the new and this-pitfalls (some atleast). At the end of the day, you still need


to know what you�re doing.



And YES I know all about Linq.js, but this library is much, much smaller


and sits ontop of lodash. I built it to avoid having to pull in lodash and Linq.js in one of my latest projects.



dependencies:


*   lodash



Install:



bower install dotNeTS




IMPORTANT NOTE FOR Visual Studio! This library includes typescript definition AND source.


You have to exclude one of them in VS to avoid duplicate definitions.



Example 1:



    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<User>

                var myList = new List<User>(arrayOfUsers);

                var userNameArray = myList.Where(b=> b.id === 1).Select(b=> b.username).ToArray();

                console.log(userNameArray);

                //=> ['olofd']

            }

        }

    }

    var userMgr = new app.UserManager();




Example 2 (Actual code from project)                    



var languagesAvailable = allLanguages.Where(s => !languagesAlreadyAdded.Where(es => es.LangCode === s.value).Any())

                        .Where(b => b.language && b.language !== "")

                        .OrderBy(b => b.language)

                        .ThenBy(b => b.country);

return languagesAvailable.ToArray();




Example 3 (Actual code from project)   



var languagesAvailable = allLanguages.Where(s => !languagesAlreadyAdded.Where(es => es.LangCode === s.value).Any())

                        .GroupBy(b => b.country)

return languagesAvailable.Where(b => b.Key === 'Sweden').ToList();




Interfaces with underlying implementations:


(* all implementations have tests.)



module dotNeTS {

    export interface IEnumerable<TSource> extends IDisposable {

        ForEach(callback: dotNeTS.IFunc<TSource, void>): void

        Contains(item: TSource): boolean;

        GroupBy<TResult>(callback: IFunc<TSource, TResult>): IEnumerable<IGrouping<TResult, TSource>>;

        OrderBy<TKey>(keySelector: dotNeTS.IFunc<TSource, TKey>): IOrderedEnumerable<TSource>;

        OrderByDecending<TKey>(callback: IFunc<TSource, TKey>): IOrderedEnumerable<TSource>;

        First(predicate?: IFunc<TSource, boolean>): TSource;

        FirstOrDefault(predicate?: IFunc<TSource, boolean>): TSource;

        Single(predicate?: IFunc<TSource, boolean>): TSource;

        SingleOrDefault(predicate?: IFunc<TSource, boolean>): TSource;

        Any(predicate?: IFunc<TSource, boolean>): boolean;

        Count(predicate?: IFunc<TSource, boolean>): number;

        Select<TResult>(callback: IFunc<TSource, TResult>): IEnumerable<TResult>;

        Where(predicate?: IFunc<TSource, boolean>): IEnumerable<TSource>;

        ToArray(): TSource[];

        ToList(): IList<TSource>;

    }

}



module dotNeTS {

    export interface IOrderedEnumerable<TSource> extends IEnumerable<TSource> {

        OrderBy<TKey>(keySelector: IFunc<TSource, TKey>): IOrderedEnumerable<TSource>;

        OrderByDecending<TSort>(callback: IFunc<TSource, TSort>): IOrderedEnumerable<TSource>;

        ThenBy<TSort>(callback: IFunc<TSource, TSort>): IOrderedEnumerable<TSource>;

        ThenByDecending<TSort>(callback: IFunc<TSource, TSort>): IOrderedEnumerable<TSource>;

    }

} 

module dotNeTS {

    export interface IList<TSource> extends IEnumerable<TSource>{

        Add(item: TSource): void;

        AddRange(collection: IEnumerable<TSource>): 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<TKey, TElement> extends IEnumerable<TElement>{

        Key: TKey;

    }

}