var cluster = new ClusterClient(new Configuration{Seeds = "broker.local:9091"}, new SomeLogger());
	cluster.Produce("some_topic", someValue);

	cluster.MessageReceived += kafkaRecord => { /* do something */ };
	cluster.ConsumeFromLatest("some_topic", somePartition);
	// OR (for consumer group usage)
	cluster.Subscribe("some group", new[] { "topic", "some_other_topic" }, new ConsumerGroupConfiguration { AutoCommitEveryMs = 5000 });

    /// <summary>
    /// Kafka version compatibility mode.
    /// 0.8.2 compatibility will work with any kafka version >= 0.8.2.
    /// However consumer group support will require brokers >= 0.9 to actually work in this mode.
    /// 0.10.1 compatibility will work with kafka >= 0.10.1.
    /// </summary>
    public Compatibility Compatibility = Compatibility.V0_8_2;

    /// <summary>
    /// Maximum amount a message can stay alive before being discarded in case of repeated errors.
    /// </summary>
    public TimeSpan MessageTtl = TimeSpan.FromMinutes(1);

    /// <summary>
    /// Period between each metadata autorefresh.
    /// </summary>
    public TimeSpan RefreshMetadataInterval = TimeSpan.FromMinutes(5);

    /// <summary>
    /// Strategy in case of network errors.
    /// </summary>
    public ErrorStrategy ErrorStrategy = ErrorStrategy.Discard;

    /// <summary>
    /// Time slice for batching messages. We wait  that much time at most before processing
    /// a batch of messages.
    /// </summary>
    public TimeSpan ProduceBufferingTime = TimeSpan.FromMilliseconds(5000);

    /// <summary>
    /// Maximum size of message batches.
    /// </summary>
    public int ProduceBatchSize = 200;

    /// <summary>
    /// Strategy for batching (per node, or global).
    /// </summary>
    public BatchStrategy BatchStrategy = BatchStrategy.ByNode;

    /// <summary>
    /// The compression codec used to compress messages to this cluster.
/// Lz4 is only supported with compatibility set to 0.10.1+
    /// </summary>
    public CompressionCodec CompressionCodec = CompressionCodec.None;

    /// <summary>
    /// If you don't provide a partition when producing a message, the partition selector will
    /// round robin between all available partitions. Use this variable to delay switching between
    /// partitions until a set number of messages has been sent (on a given topic).
    /// This is useful if you have a large number of partitions per topic and want to fully take
    /// advantage of compression (because message sets are compressed per topic/per partition).
    /// </summary>
    public int NumberOfMessagesBeforeRoundRobin = 1;

    /// <summary>
    /// Socket buffer size for send.
    /// </summary>
    public int SendBufferSize = 100 * 1024;

    /// <summary>
    /// Socket buffer size for receive.
    /// </summary>
    public int ReceiveBufferSize = 64 * 1024;

    /// <summary>
    /// Acknowledgements required.
    /// </summary>
    public RequiredAcks RequiredAcks = RequiredAcks.AllInSyncReplicas;

    /// <summary>
    /// Minimum in sync replicas required to consider a partition as alive.
    /// <= 0 means only leader is required.
    /// </summary>
    public int MinInSyncReplicas = -1;

    /// <summary>
    /// If you use MinInSyncReplicas and a broker replies with the NotEnoughReplicasAfterAppend error,
    /// we will resend the messages if this value is true.
    /// </summary>
    public bool RetryIfNotEnoughReplicasAfterAppend = false;

    /// <summary>
    /// Kafka server side timeout for requests.
    /// </summary>
    public int RequestTimeoutMs = 10000;

    /// <summary>
    /// Client side timeout: if a request is not acknowledged
    /// by this time, the connection will be reset. Obviously
    /// it should be greater than RequestTimeoutMs
    /// </summary>
    public int ClientRequestTimeoutMs = 20000;

    /// <summary>
    /// The maximum number of unacknowledged requests the client will
    /// send on a single connection before async waiting for the connection.
    /// Note that if this setting is set to be greater than 1 and there are
    /// failed sends, there is a risk of message re-ordering due to retries.
    /// </summary>
    public int MaxInFlightRequests = 5;

    /// <summary>
    /// Your client name.
    /// </summary>
    public string ClientId = "Kafka#";

    /// <summary>
    /// Brokers to which to connect to boostrap the cluster and discover the toplogy.
    /// </summary>
    public string Seeds = "";

    /// <summary>
    /// A TaskScheduler to use for all driver internal work.
    /// Useful if you want to limit the ressources taken by the driver.
    /// By default we use the default scheduler (which maps to .NET thread pool),
    /// which may induce "busy neighbours" problems in case of high overload.
    ///
    /// If this is not TaskScheduler.Default, this will always superseed
    /// the MaximumConcurrency variable.
    /// </summary>
    public TaskScheduler TaskScheduler = TaskScheduler.Default;

    /// <summary>
    /// Maximum concurrency used inside the driver. This is only taken into
    /// account if TaskScheduler is set to its default value. This is
    /// implemented using a special custom TaskScheduler which makes use of the
    /// .NET threadpool without squatting threads when there's nothing to do.
    /// </summary>
    public int MaximumConcurrency = 3;

    /// <summary>
    /// Maximum number of messages in the system before blocking/discarding send from clients.
    /// By default we never block and the number is unbounded.
    /// </summary>
    public int MaxBufferedMessages = -1;

    /// <summary>
    /// The strategy to use when the maximum number of pending produce messages
    /// has been reached. By default we block.
    /// </summary>
    public OverflowStrategy OverflowStrategy = OverflowStrategy.Block;

    /// <summary>
    /// The maximum amount of time in ms brokers will block before answering fetch requests
    /// if there isn't sufficient data to immediately satisfy FetchMinBytes
    /// </summary>
    public int FetchMaxWaitTime = 100;

    /// <summary>
    /// The minimum amount of data brokers should return for a fetch request.
    /// If insufficient data is available the request will wait for that much
    /// data to accumulate before answering the request.
    /// </summary>
    public int FetchMinBytes = 1;

    /// <summary>
    /// The number of bytes of messages to attempt to fetch for each topic-partition
    /// in each fetch request. These bytes will be read into memory for each partition,
    /// so this helps control the memory used by the consumer. The fetch request size
    /// must be at least as large as the maximum message size the server allows or else
    /// it is possible for producers to send messages larger than the consumer can fetch.
    /// </summary>
    public int FetchMessageMaxBytes = 1024 * 1024;

    /// <summary>
    /// Time slice for batching messages used when consuming (Offset and Fetch).
    /// We wait  that much time at most before processing a batch of messages.
    /// </summary>
    public TimeSpan ConsumeBufferingTime = TimeSpan.FromMilliseconds(1000);

    /// <summary>
    /// Maximum size of consume message batches (Offset and Fetch). Keep it small.
    /// </summary>
    public int ConsumeBatchSize = 10;

    /// <summary>
    /// Serialization configuration options and (de)serializers.
    /// </summary>
    public SerializationConfig SerializationConfig = new SerializationConfig();