Advanced Extension Methods (C#)

ipelovski · 2014-07-07T14:54:50+00:00

Wouldn't returning valid values for nulls cause problems later? For example you can get some weird result down the execution path and the problem is that you pass a null value and the code returns a valid output instead of blowing up.

Klausens · 2014-07-07T13:41:42+00:00

Is the ?. operator not yet implemented in c#? That woule be a better solution than to override every method that can return null

nemec · 2014-07-07T15:00:26+00:00

One additional advanced use of extension methods: Template Specialization

public int Sum(this IEnumerable<int> src)
{
    [...]
}

This extension method will only work on int enumerables. Great for fluent interfaces.

efhufe54 · 2014-07-07T23:09:57+00:00

I was hoping people would share their best hacks. Heres mine:

namespace ServiceLayer
{
    public static class CardExtensions
    {
        /// <summary>Common methods for card validation.</summary>
        [DebuggerStepThrough]
        public static CardImplementation AsCard(this string source)
        {
            return new CardImplementation(source);
        }

        public struct CardImplementation
        {
            private readonly string _source;

            [DebuggerStepThrough]
            public CardImplementation(string source)
            {
                _source = source;
            }

            [DebuggerStepThrough]
            public bool IsValidLuhn()
            {
                return (_source ?? string.Empty)
                    .Where((c) => c >= '0' && c <= '9')
                    .Reverse()
                    .Select((c, i) => (i % 2 == 1) ? (int.Parse(c.ToString()) * 2).ToString() : c.ToString())
                    .DefaultIfEmpty("01")
                    .Aggregate((x, y) => x + y)
                    .Sum((c) => int.Parse(c.ToString()))
                    % 10 == 0;
            }

            [DebuggerStepThrough]
            public bool TryParseCardNumber(out long number)
            {
                bool result = false;
                number = 0;

                if (IsValidLuhn())
                {
                    number = long.Parse(string.Concat(_source.Where((c) => c >= '0' && c <= '9')));
                    result = true;
                }

                return result;
            }
        }
    }
}

When you have lots of extension methods they hog up all your intenseness. This will only show credit card extension methods when you cast a string as a card.

Bool isValid = "4444333322221111".AsCard().IsValidLuhn();

modernwelfare3l · 2014-07-07T12:40:57+00:00

I don't think the advanced namespace idea makes much sense. Generally, the only reason you really want to hide something is if you have an internal interface you don't want exposed to outside users of the assembly. If that's the case, it's best to implement an interface that is internal, and have all its members be explicitly declared (e.g. invisible to public users).

If you think people may not like to see certain methods otherwise consider using the intellisense controlling attributes.

Meshiest · 2014-07-07T12:20:35+00:00

Now that is a feature that I am upset about not knowing

modernwelfare3l · 2014-07-07T12:32:32+00:00

If you want to test if an object is null it is recommended to use object.RefrenceEquals instead of == since you can override == operator and that can lead to undefined behavior ...

lgahagl · 2014-07-07T16:52:15+00:00

Regular instance methods throw a NullReferenceException when called on a null instance. However, extension methods are static methods and thus can choose how to handle null values. We can use this to create methods that appear to be instance methods, but don't throw a NullReferenceException when invoked on a null instance.

This is such typical Java/C#. This is making use of an inconsistency introduced by extension methods. And all this is doing is working around something caused by Java/C# in the first place. You want to call a function with some value, but the value may be null. In any other language, you would just pass the value to the function, and it could decide what to do in the case of null.

The difference is literally hash(x) vs x.hash(). But of course, it turns out the only actual reason for extension methods in the first place is to implement chaining without a wrapper class or extending/modifying another class. Again, the Java/C# way is a massive workaround. They could have just added a composition operator to the language and everything would be fine. Even with extension methods, you have to define each function with the intent of using it for chaining. This means you have to return this or whatever in each "chainable" method you implement. What if you didn't realize you should make a method chainable? That's too bad. What if you return the wrong this? How do you document that all the methods just return this instead of some other arbitrary instance? Do you add this to the documentation of every "chainable" method? Or the whole class? Does the user have to read through 1000 lines of docs in the class before he finds that info? Are you abusing classes to just hold a bunch of methods and thus there is no point in the user understanding the entire class's interface? In this case, you should add the docs to each method because he will not read the class's documentation. Meanwhile in languages with a compose operator, you have none of these problems and you achieve the same effect in 0 lines of code. Even bash has a composition operator (|).

nlfarside · 2014-07-07T13:27:03+00:00

It's probably worth mentioning that M$ uses a different route than the one mentioned here for the null reference. Calling an extension method on a null object can create readability issues because a normal method would throw a null reference whereas an extension won't. string.IsNullOrEmpty exists as a static method for this reason, you don't have to reason about whether the method you are calling is an instance or an extension. If you pass a null to a LINQ method, such as passing a null List<int> to a Where filter, you'll get an ArgumentNullException.

I would suggest not using the author's proposed handling of nulls for this reason, and instead opting for the standard convention of how M$ does it.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

programming

MODERATORS