Passing comma separated values to parameters in stored procedure
There are several ways of doing it. Changing the data model may also be a better option if you can do it.
1. Comma separated parameters
If you want to stick with the comma separated string, you can find many string split functions online using CLR, CTE, XML, ... I am not going to put them all here and I won't benchmark them. But you must know that they all have their own issues. For more information you can look at this post from Aaron Bertrand: Split strings the right way – or the next best way
Sample query (using XML conversion):
DECLARE @c1 nvarchar(100) = N'10,15,13,14';
DECLARE @delimiter nvarchar(1) = N',';
SELECT v1 = LTRIM(RTRIM(vals.node.value('(./text())[1]', 'nvarchar(4000)')))
FROM (
    SELECT x = CAST('&lt;root&gt;&lt;data&gt;' + REPLACE(@c1, @delimiter, '&lt;/data&gt;&lt;data&gt;') + '&lt;/data&gt;&lt;/root&gt;' AS XML).query('.')
) v
CROSS APPLY x.nodes('/root/data') vals(node);

Output:
v1
10
15
13
14

Main query:
The idea is to convert it to a table. It can then be used in a correlated sub query:
DECLARE @c1 nvarchar(100) = N'10,15,13,14';
DECLARE @c2 nvarchar(100) = N'C21, B21';
DECLARE @delimiter nvarchar(1) = N',';

SELECT * 
FROM FinalStatus f
WHERE EXISTS (
    SELECT 1
    FROM (
        SELECT CAST('&lt;root&gt;&lt;data&gt;' + REPLACE(@c1, @delimiter, '&lt;/data&gt;&lt;data&gt;') + '&lt;/data&gt;&lt;/root&gt;' AS XML) AS x
    )t
    CROSS APPLY x.nodes('/root/data') vals(node)
    WHERE  LTRIM(RTRIM(vals.node.value('.[1]', 'nvarchar(4000)'))) = f.Col1
)
OR EXISTS (
    SELECT 1
    FROM (
        SELECT CAST('&lt;root&gt;&lt;data&gt;' + REPLACE(@c2, @delimiter, '&lt;/data&gt;&lt;data&gt;') + '&lt;/data&gt;&lt;/root&gt;' AS XML) AS x
    )t
    CROSS APPLY x.nodes('/root/data') vals(node)
    WHERE  LTRIM(RTRIM(vals.node.value('.[1]', 'nvarchar(4000)'))) = f.Col2
);

Only the WHERE clause has to be updated in your procedure. Parameters remains of varchar type with comma separated values.
Output:
ID  Col1    Col2    Col3        LastUpdatedDate
1   10      ABC21   Msg1        2016-07-20 09:06:19.380 =&gt; match c1
2   10      ABC21   Msg2        2016-07-20 09:06:19.390 =&gt; match c1
3   11      C21     Some Msg1   2016-07-20 09:06:19.390 =&gt; match c2

2. XML parameter(s)
If you can change the parameter' types, the XML data type can be used. It can be easily deserialized by the procedure and the query.
This query is pretty similar to the previous one. However it gives a better control over invalid values and special characters since there is no conversion or search and replace.
DECLARE @c xml = N'
    &lt;root&gt;
        &lt;c1&gt;10&lt;/c1&gt;&lt;c1&gt;15&lt;/c1&gt;&lt;c1&gt;13&lt;/c1&gt;&lt;c1&gt;14&lt;/c1&gt;
        &lt;c2&gt;C21&lt;/c2&gt;&lt;c2&gt;B21&lt;/c2&gt;
    &lt;/root&gt;';
DECLARE @delimiter nvarchar(1) = N',';

SELECT * 
FROM FinalStatus f
WHERE EXISTS (
    SELECT 1
    FROM (
        SELECT x = @c.query('.')
    ) v
    CROSS APPLY x.nodes('/root/c1') val1(node)  
    WHERE  LTRIM(RTRIM(val1.node.value('.[1]', 'nvarchar(4000)'))) = f.Col1
)
OR EXISTS (
    SELECT 1
    FROM (
        SELECT x = @c.query('.')
    ) v
    CROSS APPLY x.nodes('/root/c2') val1(node)  
    WHERE  LTRIM(RTRIM(val1.node.value('.[1]', 'nvarchar(4000)'))) = f.Col2
);

The parameter' types have to be changed to xml. I used only one variable with c1 and c2 nodes but 1 variable for each node (c1, c2, ...) and different node names can also be used:
DECLARE @c1 xml = N'&lt;root&gt;&lt;data&gt;10&lt;/data&gt;&lt;data&gt;15&lt;/data&gt;&lt;data&gt;13&lt;/data&gt;&lt;data&gt;14&lt;/data&gt;&lt;/root&gt;';
DECLARE @c2 xml = N'&lt;root&gt;&lt;data&gt;C21&lt;/data&gt;&lt;data&gt;B21&lt;/data&gt;&lt;/root&gt;';
DECLARE @c3 xml = N'...';

The correct path and variables must be updated in the nodes part of the CROSS APPLY.
Using .Net, Powershell or other languages, an array or other types can easily be converted to xml and used as a parameter of the procedure.
...
3. User-Defined Table Types
Another option would be to create a Table Value Type that can be used by the Stored Procedure parameters.
Table Type
CREATE TYPE [dbo].[TableTypeCols] AS TABLE
(
    [col] varchar(15)
);

Stored Procedure with Table Type parameter(s)
You then update the Stored Procedure using this newly created type:
CREATE OR ALTER PROCEDURE [dbo].[FindResult]
    @c1 [dbo].[TableTypeCols] READONLY
    , @c2 [dbo].[TableTypeCols] READONLY
AS
    SELECT * -- fs.[...], fs.[...], ...
    FROM [dbo].[FinalStatus] fs
    WHERE 
        EXISTS (
            SELECT 1 FROM @c1 c1 WHERE c1.col = fs.Col1
        )
        OR EXISTS (
            SELECT 1 FROM @c2 c2 WHERE c2.col = fs.Col2
        );
GO;

READONLY is mandatory in the parameter declaration.
Stored Procedure call with Table Type parameter(s)
With SQL, you can call it the same way using a table variable:
DECLARE @tc1 [dbo].[TableTypeCols]; 
DECLARE @tc2 [dbo].[TableTypeCols];

INSERT INTO @tc1(col) VALUES('10'), ('15'), ('13'), ('14');
INSERT INTO @tc2(col) VALUES('C21'), ('B21');

EXEC dbo.FindResult @c1 = @tc1, @c2 = @tc2;

Output:
ID  Col1    Col2    Col3        LastUpdatedDate
1   10      ABC21   Msg1        2016-07-20 09:06:19.380 =&gt; match c1
2   10      ABC21   Msg2        2016-07-20 09:06:19.390 =&gt; match c1
3   11      C21     Some Msg1   2016-07-20 09:06:19.390 =&gt; match c2

Please note that if you are planning on using more than a couple rows for each parameters, you should run some performance test with real data and make sure it works properly on your system.
.Net C# Call
The procedure can the be call from you .Net code
// Create &amp; Fill Parameter 1
DataTable dt1 = new DataTable();
dt1.Columns.Add(&quot;col&quot;, typeof (string));
DataRow row = dt1.NewRow();
row[&quot;col&quot;] = (&quot;10&quot;);
dt1.Rows.Add(row);
/*
    ... add more row ...
*/

// Create &amp; Fill Parameter 2
DataTable dt2 = new DataTable();
dt2.Columns.Add(&quot;col&quot;, typeof (string));
DataRow row = dt2.NewRow();
row[&quot;col&quot;] = (&quot;C21&quot;);
dt2.Rows.Add(row);
/*
    ... add more row ...
*/

// Output dataset
DataSet ds = new DataSet(&quot;SQLDatabase&quot;);

using (SqlConnection conn = new SqlConnection(...))
{
    // Stored Procedure with table parameters
    SqlCommand sqlComm = new SqlCommand(&quot;dbo.FindResult&quot;, conn);
    sqlComm.CommandType = CommandType.StoredProcedure;

    // Parameter 1
    SqlParameter param = new SqlParameter(&quot;@c1&quot;, SqlDbType.Structured)
    {
        TypeName = &quot;dbo.TableTypeCols&quot;,
        Value = dt1
    };
    sqlComm.Parameters.Add(param);

    // Parameter 2
    SqlParameter param = new SqlParameter(&quot;@c2&quot;, SqlDbType.Structured)
    {
        TypeName = &quot;dbo.TableTypeCols&quot;,
        Value = dt2
    };
    sqlComm.Parameters.Add(param);

    // Call Stored Procedure
    SqlDataAdapter da = new SqlDataAdapter();
    da.SelectCommand = sqlComm;
    da.Fill(ds);
}

SqlDbType.Structured is mandatory.
Please note that I am not a .Net expert and there are other or better ways to write and use this code.
4. Json Type Parameters (Since SQL Server 2016)
With minimal changes, you can declare a NVARCHAR(MAX) parameters with json string.
json parameters
DECLARE @C1 NVARCHAR(MAX);
SET @jsonC1 =  
N'[
    { &quot;col&quot; : &quot;10&quot;}, { &quot;col&quot; : &quot;15&quot;}, { &quot;col&quot; : &quot;13&quot;}, { &quot;col&quot; : &quot;14&quot;}
]';
DECLARE @C2 NVARCHAR(MAX);
SET @jsonC2 =  
N'[
    { &quot;col&quot; : &quot;C21&quot;}, { &quot;col&quot; : &quot;B21&quot;}
]';

Query
SELECT * 
FROM dbo.FinalStatus f
WHERE 
EXISTS (
    SELECT 1 FROM OPENJSON(@C1) WITH(col nvarchar(15)) AS c1 WHERE c1.col = f.Col1
)
OR
EXISTS (
    SELECT 1 FROM OPENJSON(@C2) WITH(col nvarchar(15)) AS c2 WHERE c2.col = f.Col2 
);

Please note that OPENJSON requires SQL Server 2016.