Below find my comments and suggestions inline in the C# code (I'm not an expert on BlockChains so this is just use of my version of common sense and some programming experience):

  public static class IntExtesions
  {
    public static string ToHex(this int i)
    {
      return i.ToString("x");
    }

    // For completeness make a ToHex for byte as well
    public static string ToHex(this byte b)
    {
      return b.ToString("x2");
    }
  }

  public class Block : IEquatable<Block>
  {
    public Block(int index, string previousHash, DateTime timestamp, string data, string hash, int difficulty, int nonce)
    {
      Index = index; 
      PreviousHash = previousHash;
      Timestamp = timestamp;
      Data = data;
      Hash = hash;
      Difficulty = difficulty;
      Nonce = nonce;
    }

    // I'm not sure if an index is good as a property on the block. 
    //Shouldn't the index be determined by the position in the block chain?
    public int Index { get; } 

    public string PreviousHash { get; }
    public DateTime Timestamp { get; }
    public string Data { get; }
    public string Hash { get; }
    public int Difficulty { get; }
    //public string Nonce { get; }  // I would keep the Nonce as a number
    public int Nonce { get; }

    public bool Equals(Block other)
    {
      if (other is null) return false;
      if (ReferenceEquals(this, other)) return true;

      return Index == other.Index &&
             string.Equals(PreviousHash, other.PreviousHash) &&
             Timestamp.Equals(other.Timestamp) &&
             string.Equals(Data, other.Data) &&
             string.Equals(Hash, other.Hash);
    }

    public override bool Equals(object obj)
    {
      if (obj is null) return false;
      if (ReferenceEquals(this, obj)) return true;

      return obj.GetType() == this.GetType() && Equals((Block)obj);
    }

    public override int GetHashCode()
    {
      unchecked
      {
        var hashCode = Index;
        hashCode = (hashCode * 397) ^ (PreviousHash != null ? PreviousHash.GetHashCode() : 0);
        hashCode = (hashCode * 397) ^ Timestamp.GetHashCode();
        hashCode = (hashCode * 397) ^ (Data != null ? Data.GetHashCode() : 0);
        hashCode = (hashCode * 397) ^ (Hash != null ? Hash.GetHashCode() : 0);

        return hashCode;
      }
    }
  }

  public class Blockchain
  {
    // Consider make Chain private and then implement IEnumerable<Block> on BlockChain.
    // This will prevent "unauthorized" modification of the chain.
    // You'll then have to create methods for Add and Remove, and Count etc.
    public List<Block> Chain { get; private set; } = new List<Block>();
    public int Difficulty { get; } = 1; // A difficulty of 1 seems not to be very "difficult" :-). Maybe it should be an argument to the constructor?

    // It seems that you don't add the GenesisBlock to the Chain?
    public Block GenesisBlock => new Block(0, "0", new
        DateTime(2000, 1, 1), "Genesis block",
        "816534932c2b7154836da6afc367695e6337db8a921823784c14378abed4f7d7",
        1, 0);

    // I'm not sure I understand what this method is good for?
    public void ReplaceChain(List<Block> newChain)
    {
      if (newChain.Count > Chain.Count && ChainIsValid(newChain))
      {
        // Be aware that doing this:
        // Chain = newChain;
        // you actually only hold a reference to the incoming list. If someone outside this instance of BlockChain modifies that list, this instance may not behave as expected.
        // Instead you should make a copy:
        Chain = new List<Block>(newChain);

      }

      // TODO: If the new chain is rejected then the client should be nofitied: throw an exception or return false
    }

    public Block GenerateNextBlock(string blockData)
    {
      var previousBlock = GetLatestBlock();
      var nextIndex = previousBlock.Index + 1;
      var nextTimestamp = DateTime.Now;

      var nonce = 0;
      //bool hashIsValid = false;
      //string hexNonce = null;
      string nextHash = null;

      // With a modifed IsHasValid(...) (see below) you can do this:
      while (!HashIsValid(nextHash, Difficulty))
      {
        nextHash = CalculateBlockHash(nextIndex, previousBlock.Hash, nextTimestamp, blockData, nonce);
        nonce++; // Here you actually increment nonce once too much when the hash is valid
      }

      // ... instead of
      //while (!hashIsValid)
      //{
      //  hexNonce = nonce.ToHex();
      //  nextHash = CalculateBlockHash(nextIndex, previousBlock.Hash, nextTimestamp, blockData, hexNonce);

      //  if (HashIsValid(nextHash, Difficulty))
      //  {
      //    hashIsValid = true;
      //  }

      //  nonce++; // Here you actually increment nonce once too much when the hash is valid
      //}

      nonce--; // Decrement once for the last increment in the loop above

      return new Block(nextIndex, previousBlock.Hash, nextTimestamp, blockData, nextHash, Difficulty, nonce);
    }

    // Instead of defining the hash computation once here, consider injecting an IHashCalculator { string ComputeHash(Block block); } into the BlockCain constructor
    // It will make it possible for you to easily change the hash algorithm
    public string CalculateBlockHash(int index, string previousHash, DateTime timestamp, string data, int nonce)
    {
      //var sb = new StringBuilder();

      using (var hash = SHA256.Create())
      {
        // Instead of this...:
        //var value = index +
        //            previousHash +
        //            timestamp.ToString(CultureInfo.InvariantCulture.DateTimeFormat.FullDateTimePattern) +
        //            data +
        //            nonce;

        //var result = hash.ComputeHash(Encoding.UTF8.GetBytes(value));

        // ... I would do something like this:
        byte[] buffer =
          BitConverter
          .GetBytes(timestamp.Ticks)
          .Concat(Encoding.UTF8.GetBytes(data))
          .Concat(Encoding.Unicode.GetBytes(previousHash))
          .Concat(BitConverter.GetBytes(nonce))
          .ToArray();
        var result = hash.ComputeHash(buffer);


        // This can be done...
        //foreach (var b in result)
        //  //sb.Append(b.ToString("x2")); // Make an extension for bytes too to keep it up to int
        //  sb.Append(b.ToHex());

        // ... this way:
        return string.Join("", result.Select(b => b.ToHex()));
      }

      //return sb.ToString();
    }

    public string CalculateBlockHash(Block block)
    {
      return CalculateBlockHash(block.Index, block.PreviousHash, block.Timestamp, block.Data, block.Nonce);
    }

    private bool ChainIsValid(IReadOnlyList<Block> chain)
    {
      if (!chain[0].Equals(GenesisBlock))
      {
        return false;
      }

      for (var i = 1; i < chain.Count; i++)
      {
        if (!BlockIsValid(chain[i], chain[i - 1]))
        {
          return false;
        }
      }

      return true;
    }

    private bool BlockIsValid(Block newBlock, Block previousBlock)
    {
      if (previousBlock.Index + 1 != newBlock.Index)
      {
        return false;
      }

      if (previousBlock.Hash != newBlock.PreviousHash)
      {
        return false;
      }

      return CalculateBlockHash(newBlock) == newBlock.Hash;
    }

    private static bool HashIsValid(string hash, int difficulty)
    {
      // This can be done nicer
      //var prefix = string.Concat(Enumerable.Repeat('0', difficulty));
      var prefix = new string('0', difficulty);

      // Check the hash for null allowing this method to be used more smoothly
      return hash != null && hash.StartsWith(prefix);
    }

    private Block GetLatestBlock()
    {
      return Chain.Last();
    }
  }

Below find my review of the F# code:

open System
open System.Security.Cryptography
open System.Globalization
open System.Text
open System.Collections
open System.Collections.Generic
open System.Linq


// To create an extension function do this:
type Int32 with
    member this.toHex() = this.ToString("x")

type Byte with 
    member this.toHex() = this.ToString("x2")


type Block(index: int, previousHash: string, timestamp: DateTime, data: string, blockHash: string, difficulty: int, nonce: int) =
    member val Index = index // As for the C# version, Index is IMO redundant and potentially a source for inconsistency
    member val PreviousHash = previousHash
    member val Timestamp = timestamp
    member val Data = data
    member val Hash = blockHash
    member val Difficulty = difficulty // I don't see the necessity for the Difficulty as a member on the block because it is invariant at the Block level?
    member val Nonce = nonce

    override this.Equals(obj) =
        match obj with
        | :? Block as b -> (index, previousHash, timestamp, data, blockHash) = (b.Index, b.PreviousHash, b.Timestamp, b.Data, b.Hash)
        | _ -> false

    // I think this:...
    //override this.GetHashCode() =
    //    let mutable hashCode = index
    //    hashCode <- (hashCode * 397) ^^^ (if previousHash <> null then previousHash.GetHashCode() else 0)
    //    hashCode <- (hashCode * 397) ^^^ timestamp.GetHashCode();
    //    hashCode <- (hashCode * 397) ^^^ (if data <> null then data.GetHashCode() else 0)
    //    hashCode <- (hashCode * 397) ^^^ (if hash <> null then hash.GetHashCode() else 0)
    //    hashCode

    // ... can be simplified to this:
    override this.GetHashCode() =
        [
            index; 
            (if previousHash <> null then previousHash.GetHashCode() else 0); // This should never be null.
            timestamp.GetHashCode(); 
            (if data <> null then data.GetHashCode() else 0); // I wonder if data will ever be null? Should it be possible to create a block without content?
            (if blockHash <> null then blockHash.GetHashCode() else 0) // This should never be null.
        ]
        |> List.fold (fun acc n -> (acc * 397) ^^^ n) 0

        // If you will use hash in FSharp.Core.Operators it is more readable and produces the same hash
        // So my guess is that it uses the same hash functions as you do - it's just a nice convenience function
        //[
        //    hash index; 
        //    hash previousHash; 
        //    hash timestamp; 
        //    hash data; 
        //    hash blockHash
        //]
        //|> List.fold (fun acc n -> (acc * 397) ^^^ n) 0

// I think I would call it BlockCain because it's a concatenation of two words
type Blockchain() =
    // You can use a Sytem.Collections.Generics.List instead of an array - it's more flexible but of cause more .NET-ish than functional
    let mutable chain = new List<Block>([ Blockchain.GenesisBlock ])

    // When implementing IEnumerable<Block> (see below) this should not be exposed as public
    //member private this.Chain 
    //    with get() = chain
    //    and set(value) = chain <- value

    member val Difficulty = 1

    // There is no reason to let this be part of the instance - it should be the same for all instances
    static member GenesisBlock = 
        new Block(0, "0", new DateTime(2000, 1, 1), "Genesis block", 
            "816534932c2b7154836da6afc367695e6337db8a921823784c14378abed4f7d7", 1, 0) // The Difficulty argument is a "magic" number, which you may forget to synchronize with that of Blockchain - consider avoiding completely

    member this.ReplaceChain(newChain: List<Block>) =
        if newChain.Count > chain.Count && this.ChainIsValid newChain then 
            chain <- new List<Block>(newChain) // Make a copy instead of a reference

    // I've made all the block generation functions private, because they should only be called once per new added block or at least called in a private context
    member private this.GenerateNextBlock(blockData) =
        let previousBlock: Block = this.GetLatestBlock()
        let currentIndex = previousBlock.Index + 1 // currentIndex is better than nextIndex because you actually handle the current block
        let currentTimestamp = DateTime.Now // current for the same reason as above.

        let rec generateBlock nonce =
            //let hexNonce = Int32.toHex(nonce) // Keep nonce as int
            // currentHash is better than nextHash
            let currentHash = this.CalculateBlockHash(currentIndex, previousBlock.Hash, currentTimestamp, blockData, nonce)
            match this.HashIsValid(currentHash, this.Difficulty) with
                | true -> new Block(currentIndex, previousBlock.Hash, currentTimestamp, blockData, currentHash, this.Difficulty, nonce - 1) // last recursion makes nonce one too large
                | false -> generateBlock (nonce + 1)

        generateBlock 0

    // Again inject the hash calculation as an interface or function 
    member private this.CalculateBlockHash((index: int), previousHash, (timestamp: DateTime), data, nonce) =
        use algorithm = SHA256.Create() // algorithm is a better name than hash
        [index.ToString(); previousHash; timestamp.ToString(CultureInfo.InvariantCulture.DateTimeFormat.FullDateTimePattern); data; nonce.toHex()]
            |> String.Concat
            |> Encoding.UTF8.GetBytes
            |> algorithm.ComputeHash
            //|> Encoding.UTF8.GetString // I don't understand this?
            //|> (+) "x2" // I don't understand this?
            |> fun bytes -> String.Join("", bytes.Select(fun b -> b.toHex()))

    member private this.CalculateBlockHash(block: Block) =
        this.CalculateBlockHash(block.Index, block.PreviousHash, block.Timestamp, block.Data, block.Nonce)

    member private this.ChainIsValid(chain) =
        match chain.[0].Equals Blockchain.GenesisBlock with  // Changed GenesisBlock from instance to static
            | true -> chain |> Seq.pairwise |> Seq.forall this.BlockIsValid // The lambda wrapper is not necessary here: (fun (a, b) -> this.BlockIsValid(a, b))
            | false -> false

    member private this.BlockIsValid(previousBlock, newBlock) = // I've swapped previousBlock and newBlock, because that is the order in which the are passed to the function.
        if previousBlock.Index + 1 <> newBlock.Index then
            false
        else if previousBlock.Hash <> newBlock.PreviousHash then
            false
        else
            this.CalculateBlockHash newBlock = newBlock.Hash

    member private this.HashIsValid(hash, difficulty) =
        let prefix = String('0', difficulty) //  (Seq.replicate difficulty '0') |> String.Concat
        hash.StartsWith(prefix)

    member private this.GetLatestBlock() = chain.Last()

    // Add some new data, create a new Block and add it to the chain
    member public this.AddData(data:string) = 
        if data = null then raise (ArgumentNullException("data"))
        let block = this.GenerateNextBlock(data)
        this.Add(block)

    member public this.Add(block) = chain.Add(block)

    // Implementation of IEnumerable<Block> instead of exposing the chain it self
    interface IEnumerable<Block> with
        member this.GetEnumerator() = (chain :> IEnumerable<Block>).GetEnumerator()
    // Implementation of IEnumerable
    interface IEnumerable with 
        member this.GetEnumerator() = (chain :> IEnumerable).GetEnumerator()