Tips and tricks in C# .NET
May 8, 2015 1 Comment
In this post we saw how to implement the generic IEquatable interface to make two custom objects equatable using the static Equals method.
You’re probably aware of the equality operator ‘==’ in C#. Let’s see what happens if you try to use it for a custom object:
public class Person
{
public int Id { get; set; }
public string Name { get; set; }
public int Age { get; set; }
}
May 7, 2015 1 Comment
Introduction
In the previous post we looked at letter ‘L’ in SOLID, i.e. the Liskov Substitution Principle. We saw how adhering to the LSP helps remove implementation-specific details from a client class that consumes those implementations. The client class will be able to consume the services of an abstraction without worrying about the actual implementation of the abstraction. The goal of LSP is that any implementation of an abstraction will work seamlessly within the consuming class.
We looked at the following cases that can indicate a violation of LSP:
There’s at least one more indicator which we haven’t seen so far. I decided to devote a separate article to that case as it brings us closer to the next constituent of SOLID, i.e. the Interface Segregation Principle.
May 6, 2015 2 Comments
The generic IEqualityComparer of T provides you a way to indicate whether two custom objects are equal. We’ve looked at equality in a number of posts on this blog – see the link below if you’re curious – and IEqualityComparer fulfils a similar purpose though its usage is different.
Equality comparers are most often used to filter out duplicates from a collection.
Consider the following class:
May 5, 2015 5 Comments
In this short post we’ll see a way how to make two custom objects equatable using the generic IEquatable interface. Consider the following object:
public class Person
{
public int Id { get; set; }
public string Name { get; set; }
public int Age { get; set; }
}
The object superclass has an Equals method that we can test as follows:
May 4, 2015 1 Comment
Introduction
In the previous post we looked at the Open-Closed Principle, i.e. ‘O’ in the SOLID acronym. We saw how the OCP facilitated the flexibility and extensibility of a class. It also places a constraint on a class by making it “append-only”. In other words you can extend a class but you cannot change the implementation of existing parts of a class.
In this post we’ll take a look at letter ‘L’ which stands for the Liskov Substitution Principle LSP.
Definition of LSP
LSP stands for the interchangeability of different implementations of an abstraction. An abstraction in C#, and probably most other popular object-oriented programming languages, can either be an abstract base class or an interface. According to LSP it shouldn’t make any difference what implementation of an abstraction you call from a client. Any concrete implementation of the abstraction should behave in a way that doesn’t break the client and doesn’t produce any unexpected and/or incorrect results. The client shouldn’t ever be concerned with the implementation details of an abstraction. It should be able to consume any concrete implementation “without batting an eye”.
May 3, 2015 Leave a comment
Introduction
In the previous post we successfully queried the limited IPv4 range table in DynamoDb and found the geoname ID that belongs to a single IP. We used 3 available integer properties in the table to narrow down the number of records that had to be scanned to reduce the query execution time and the risk for exceptions.
In this post we’ll start the same process for the lng/lat coordinate range. More specifically we’ll prepare the raw data file that can be uploaded into DynamoDb through S3. The process will be very similar to what we saw in this post where we created the IPv4 range source file. It is good idea to quickly re-scan that post to remind you of the process.
May 2, 2015 Leave a comment
Introduction
In the previous post we loaded the limited IP range records into DynamoDb. As we’re only talking about about 250 records we could have added them in code one by one. However, that strategy would never work for the full MaxMind IP data set of 10 million records. So instead we looked at the built-in Import/Export functionality in DynamoDb. You’ll be able to go through the same process when you’re ready to import the full data set.
In this post we’ll see how to query the IP range database to extract the ID of the nearest geolocation. We’ll get to use the AWS Java SDK.
May 1, 2015 Leave a comment
In this post we showed how to declare natural ordering for a custom type by implementing the generic IComparable interface. We saw that it required us to implement the CompareTo method. The example we looked at was a simple Triangle class where we said that triangles can be ordered based on their areas. That’s probably a reasonable comparison for triangle.
However, what about the following object?
public class Building
{
public double Area { get; set; }
public int NumberOfRooms { get; set; }
public string Address { get; set; }
public bool ForSale { get; set; }
public DateTime DateBuilt { get; set; }
}
April 30, 2015 3 Comments
Introduction
In the previous post we looked at the letter ‘S’ in SOLID, i.e. the single responsibility principle. We identified the reasons for change in the OnDemandAgentService class and broke out 3 of them into separate classes. The OnDemandAgentService can now concentrate on starting a new on-demand agent and delegate other tasks to specialised services such as EmailService. Also, an additional benefit is that other classes in the assembly can re-use those specialised services so that e.g. logging can be centralised.
In this post we’ll look at the second constituent of the SOLID principles, the letter ‘O’ which stands for the Open-Closed Principle OCP.
April 29, 2015 Leave a comment
Primitive types such as integers can be ordered naturally in some way. Numeric and alphabetical ordering comes in handy with numbers and strings. However, there’s no natural ordering for your own custom objects with a number of properties.
Consider the following Triangle class:
public class Triangle
{
public double BaseSide { get; set; }
public double Height { get; set; }
public double Area
{
get
{
return (BaseSide * Height) / 2;
}
}
}
A directory of wonderful thoughts
Web development
Various tidbits
WEB APPLICATION DEVELOPMENT TUTORIALS WITH OPEN-SOURCE PROJECTS
ARCHIVED: Bite-size insight on Cyber Security for the not too technical.
Exercises in .NET with Andras Nemes 