C#

Fan-Out metric is the number of classes that a particular class relies 
on. Fan-In metric is the number of classes that make use of a given class. 
The ripple impact measure counts the total number of classes that might 
have an impact when any single class is changed. Based on the dependency 
graph above, if we were to modify "E", the ripple will impact B directly, 
since B has an impact this will impact A as well. In short any change made 
to ‘E’ can have a potential ripple impact on B and A.

The nodes in the dependency graph that have a Fan-Out of Zero are known as 
a Sink node. Nodes that have a Fan-In of zero are known as Source nodes.

In the dependency graph shown, we can extract the following information:
• A: Fan-out = 1 [B], Fan-In = 0, Impact-Ripple = 0
• B: Fan-Out = 3 [D, E, F], Fan-In = 1 [A], Impact-Ripple = 1 [A]
• C: Fan-Out = 1 [D], Fan-In = 1 [F], Impact-Ripple = 4 [F, D, B, A]
• D: Fan-Out = 1 [F], Fan-In = 2 [C, B], Impact-Ripple = 4 [B,A,C, F]
• E: Fan-Out = 0, Fan-In = 1, Impact-Ripple = 2 [B,A]
• F: Fan-Out = 1, Fan-In = 2, Impact-Ripple = 4 [B,D,A,C]
• Sink nodes: E, Source nodes: A

public class Node
{
   ...

   public List<Node> FanIn
   {
       get
       {
           return this.fanIn;
       }
   }

   public HashSet<Node> Ripple
   {
       get
       {
            HashSet<Node> rippleSet = new HashSet<Node>();
            
            // add this node for easy cycle checking so we don't
            // process ourself twice
            rippleSet.Add(this);
            
            // call our recursive function
            this.CalcRipple(rippleSet);

            // remember to remove us so we don't skew the result
            rippleSet.Remove(this);

            return rippleSet;
       }
   }

   private void CalcRipple(HashSet<Node> rippleSet)
   {
       // source nodes exit here...
       foreach (Node node in this.FanIn)
       {
            // try and add the node to the set - if it fails then we
            // have already visited it before as it already exists in
            // the set, other wise the node gets added and we need to 
            // process its fan-in nodes. 
            //
            // as far as i can tell this results in us performing a
            // depth first traversal of the graph
            if (rippleSet.Add(node))
            {
                node.CalcRipple(rippleSet);
            }
        }
   }

   ...
}